Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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

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

1//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the actions class which performs semantic analysis and
10// builds an AST out of a parse stream.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTDiagnostic.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclFriend.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprCXX.h"
21#include "clang/AST/PrettyDeclStackTrace.h"
22#include "clang/AST/StmtCXX.h"
23#include "clang/Basic/DiagnosticOptions.h"
24#include "clang/Basic/PartialDiagnostic.h"
25#include "clang/Basic/TargetInfo.h"
26#include "clang/Lex/HeaderSearch.h"
27#include "clang/Lex/Preprocessor.h"
28#include "clang/Sema/CXXFieldCollector.h"
29#include "clang/Sema/DelayedDiagnostic.h"
30#include "clang/Sema/ExternalSemaSource.h"
31#include "clang/Sema/Initialization.h"
32#include "clang/Sema/MultiplexExternalSemaSource.h"
33#include "clang/Sema/ObjCMethodList.h"
34#include "clang/Sema/Scope.h"
35#include "clang/Sema/ScopeInfo.h"
36#include "clang/Sema/SemaConsumer.h"
37#include "clang/Sema/SemaInternal.h"
38#include "clang/Sema/TemplateDeduction.h"
39#include "clang/Sema/TemplateInstCallback.h"
40#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/SmallSet.h"
42#include "llvm/Support/TimeProfiler.h"
43
44using namespace clang;
45using namespace sema;
46
47SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
48 return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
49}
50
51ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
52
53PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
54 const Preprocessor &PP) {
55 PrintingPolicy Policy = Context.getPrintingPolicy();
56 // In diagnostics, we print _Bool as bool if the latter is defined as the
57 // former.
58 Policy.Bool = Context.getLangOpts().Bool;
59 if (!Policy.Bool) {
60 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
61 Policy.Bool = BoolMacro->isObjectLike() &&
62 BoolMacro->getNumTokens() == 1 &&
63 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
64 }
65 }
66
67 return Policy;
68}
69
70void Sema::ActOnTranslationUnitScope(Scope *S) {
71 TUScope = S;
72 PushDeclContext(S, Context.getTranslationUnitDecl());
73}
74
75namespace clang {
76namespace sema {
77
78class SemaPPCallbacks : public PPCallbacks {
79 Sema *S = nullptr;
80 llvm::SmallVector<SourceLocation, 8> IncludeStack;
81
82public:
83 void set(Sema &S) { this->S = &S; }
84
85 void reset() { S = nullptr; }
86
87 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
88 SrcMgr::CharacteristicKind FileType,
89 FileID PrevFID) override {
90 if (!S)
91 return;
92 switch (Reason) {
93 case EnterFile: {
94 SourceManager &SM = S->getSourceManager();
95 SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
96 if (IncludeLoc.isValid()) {
97 if (llvm::timeTraceProfilerEnabled()) {
98 const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
99 llvm::timeTraceProfilerBegin(
100 "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
101 }
102
103 IncludeStack.push_back(IncludeLoc);
104 S->DiagnoseNonDefaultPragmaPack(
105 Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
106 }
107 break;
108 }
109 case ExitFile:
110 if (!IncludeStack.empty()) {
111 if (llvm::timeTraceProfilerEnabled())
112 llvm::timeTraceProfilerEnd();
113
114 S->DiagnoseNonDefaultPragmaPack(
115 Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
116 IncludeStack.pop_back_val());
117 }
118 break;
119 default:
120 break;
121 }
122 }
123};
124
125} // end namespace sema
126} // end namespace clang
127
128Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
129 TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
130 : ExternalSource(nullptr), isMultiplexExternalSource(false),
131 FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
132 Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
133 SourceMgr(PP.getSourceManager()), CollectStats(false),
134 CodeCompleter(CodeCompleter), CurContext(nullptr),
135 OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
136 MSPointerToMemberRepresentationMethod(
137 LangOpts.getMSPointerToMemberRepresentationMethod()),
138 VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
139 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
140 CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
141 PragmaAttributeCurrentTargetDecl(nullptr),
142 IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
143 LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
144 StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),
145 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
146 MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
147 NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
148 ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
149 ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
150 DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
151 TUKind(TUKind), NumSFINAEErrors(0),
152 FullyCheckedComparisonCategories(
153 static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
154 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
155 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
156 CurrentInstantiationScope(nullptr), DisableTypoCorrection(false),
157 TyposCorrected(0), AnalysisWarnings(*this),
158 ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
159 CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
160 TUScope = nullptr;
161
162 LoadedExternalKnownNamespaces = false;
163 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
164 NSNumberLiteralMethods[I] = nullptr;
165
166 if (getLangOpts().ObjC)
167 NSAPIObj.reset(new NSAPI(Context));
168
169 if (getLangOpts().CPlusPlus)
170 FieldCollector.reset(new CXXFieldCollector());
171
172 // Tell diagnostics how to render things from the AST library.
173 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
174
175 ExprEvalContexts.emplace_back(
176 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
177 nullptr, ExpressionEvaluationContextRecord::EK_Other);
178
179 // Initialization of data sharing attributes stack for OpenMP
180 InitDataSharingAttributesStack();
181
182 std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
183 llvm::make_unique<sema::SemaPPCallbacks>();
184 SemaPPCallbackHandler = Callbacks.get();
185 PP.addPPCallbacks(std::move(Callbacks));
186 SemaPPCallbackHandler->set(*this);
187}
188
189void Sema::addImplicitTypedef(StringRef Name, QualType T) {
190 DeclarationName DN = &Context.Idents.get(Name);
191 if (IdResolver.begin(DN) == IdResolver.end())
192 PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
193}
194
195void Sema::Initialize() {
196 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
197 SC->InitializeSema(*this);
198
199 // Tell the external Sema source about this Sema object.
200 if (ExternalSemaSource *ExternalSema
201 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
202 ExternalSema->InitializeSema(*this);
203
204 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
205 // will not be able to merge any duplicate __va_list_tag decls correctly.
206 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
207
208 if (!TUScope)
209 return;
210
211 // Initialize predefined 128-bit integer types, if needed.
212 if (Context.getTargetInfo().hasInt128Type()) {
213 // If either of the 128-bit integer types are unavailable to name lookup,
214 // define them now.
215 DeclarationName Int128 = &Context.Idents.get("__int128_t");
216 if (IdResolver.begin(Int128) == IdResolver.end())
217 PushOnScopeChains(Context.getInt128Decl(), TUScope);
218
219 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
220 if (IdResolver.begin(UInt128) == IdResolver.end())
221 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
222 }
223
224
225 // Initialize predefined Objective-C types:
226 if (getLangOpts().ObjC) {
227 // If 'SEL' does not yet refer to any declarations, make it refer to the
228 // predefined 'SEL'.
229 DeclarationName SEL = &Context.Idents.get("SEL");
230 if (IdResolver.begin(SEL) == IdResolver.end())
231 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
232
233 // If 'id' does not yet refer to any declarations, make it refer to the
234 // predefined 'id'.
235 DeclarationName Id = &Context.Idents.get("id");
236 if (IdResolver.begin(Id) == IdResolver.end())
237 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
238
239 // Create the built-in typedef for 'Class'.
240 DeclarationName Class = &Context.Idents.get("Class");
241 if (IdResolver.begin(Class) == IdResolver.end())
242 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
243
244 // Create the built-in forward declaratino for 'Protocol'.
245 DeclarationName Protocol = &Context.Idents.get("Protocol");
246 if (IdResolver.begin(Protocol) == IdResolver.end())
247 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
248 }
249
250 // Create the internal type for the *StringMakeConstantString builtins.
251 DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
252 if (IdResolver.begin(ConstantString) == IdResolver.end())
253 PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
254
255 // Initialize Microsoft "predefined C++ types".
256 if (getLangOpts().MSVCCompat) {
257 if (getLangOpts().CPlusPlus &&
258 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
259 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
260 TUScope);
261
262 addImplicitTypedef("size_t", Context.getSizeType());
263 }
264
265 // Initialize predefined OpenCL types and supported extensions and (optional)
266 // core features.
267 if (getLangOpts().OpenCL) {
268 getOpenCLOptions().addSupport(
269 Context.getTargetInfo().getSupportedOpenCLOpts());
270 getOpenCLOptions().enableSupportedCore(getLangOpts());
271 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
272 addImplicitTypedef("event_t", Context.OCLEventTy);
273 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
274 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
275 addImplicitTypedef("queue_t", Context.OCLQueueTy);
276 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
277 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
278 addImplicitTypedef("atomic_uint",
279 Context.getAtomicType(Context.UnsignedIntTy));
280 auto AtomicLongT = Context.getAtomicType(Context.LongTy);
281 addImplicitTypedef("atomic_long", AtomicLongT);
282 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
283 addImplicitTypedef("atomic_ulong", AtomicULongT);
284 addImplicitTypedef("atomic_float",
285 Context.getAtomicType(Context.FloatTy));
286 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
287 addImplicitTypedef("atomic_double", AtomicDoubleT);
288 // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
289 // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
290 addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
291 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
292 addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
293 auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
294 addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
295 auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
296 addImplicitTypedef("atomic_size_t", AtomicSizeT);
297 auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
298 addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
299
300 // OpenCL v2.0 s6.13.11.6:
301 // - The atomic_long and atomic_ulong types are supported if the
302 // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
303 // extensions are supported.
304 // - The atomic_double type is only supported if double precision
305 // is supported and the cl_khr_int64_base_atomics and
306 // cl_khr_int64_extended_atomics extensions are supported.
307 // - If the device address space is 64-bits, the data types
308 // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
309 // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
310 // cl_khr_int64_extended_atomics extensions are supported.
311 std::vector<QualType> Atomic64BitTypes;
312 Atomic64BitTypes.push_back(AtomicLongT);
313 Atomic64BitTypes.push_back(AtomicULongT);
314 Atomic64BitTypes.push_back(AtomicDoubleT);
315 if (Context.getTypeSize(AtomicSizeT) == 64) {
316 Atomic64BitTypes.push_back(AtomicSizeT);
317 Atomic64BitTypes.push_back(AtomicIntPtrT);
318 Atomic64BitTypes.push_back(AtomicUIntPtrT);
319 Atomic64BitTypes.push_back(AtomicPtrDiffT);
320 }
321 for (auto &I : Atomic64BitTypes)
322 setOpenCLExtensionForType(I,
323 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
324
325 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
326 }
327
328 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
329
330#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext)setOpenCLExtensionForType(Context.Id, Ext); \
331 setOpenCLExtensionForType(Context.Id, Ext);
332#include "clang/Basic/OpenCLImageTypes.def"
333#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
334 addImplicitTypedef(#ExtType, Context.Id##Ty); \
335 setOpenCLExtensionForType(Context.Id##Ty, #Ext);
336#include "clang/Basic/OpenCLExtensionTypes.def"
337 };
338
339 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
340 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
341 if (IdResolver.begin(MSVaList) == IdResolver.end())
342 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
343 }
344
345 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
346 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
347 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
348}
349
350Sema::~Sema() {
351 if (VisContext) FreeVisContext();
352
353 // Kill all the active scopes.
354 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
355 delete FSI;
356
357 // Tell the SemaConsumer to forget about us; we're going out of scope.
358 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
359 SC->ForgetSema();
360
361 // Detach from the external Sema source.
362 if (ExternalSemaSource *ExternalSema
363 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
364 ExternalSema->ForgetSema();
365
366 // If Sema's ExternalSource is the multiplexer - we own it.
367 if (isMultiplexExternalSource)
368 delete ExternalSource;
369
370 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
371
372 // Destroys data sharing attributes stack for OpenMP
373 DestroyDataSharingAttributesStack();
374
375 // Detach from the PP callback handler which outlives Sema since it's owned
376 // by the preprocessor.
377 SemaPPCallbackHandler->reset();
378
379 assert(DelayedTypos.empty() && "Uncorrected typos!")((DelayedTypos.empty() && "Uncorrected typos!") ? static_cast
<void> (0) : __assert_fail ("DelayedTypos.empty() && \"Uncorrected typos!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 379, __PRETTY_FUNCTION__))
;
380}
381
382/// makeUnavailableInSystemHeader - There is an error in the current
383/// context. If we're still in a system header, and we can plausibly
384/// make the relevant declaration unavailable instead of erroring, do
385/// so and return true.
386bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
387 UnavailableAttr::ImplicitReason reason) {
388 // If we're not in a function, it's an error.
389 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
390 if (!fn) return false;
1
Taking false branch
391
392 // If we're in template instantiation, it's an error.
393 if (inTemplateInstantiation())
2
Taking false branch
394 return false;
395
396 // If that function's not in a system header, it's an error.
397 if (!Context.getSourceManager().isInSystemHeader(loc))
3
Taking false branch
398 return false;
399
400 // If the function is already unavailable, it's not an error.
401 if (fn->hasAttr<UnavailableAttr>()) return true;
4
Taking false branch
402
403 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
5
Calling 'UnavailableAttr::CreateImplicit'
404 return true;
405}
406
407ASTMutationListener *Sema::getASTMutationListener() const {
408 return getASTConsumer().GetASTMutationListener();
409}
410
411///Registers an external source. If an external source already exists,
412/// creates a multiplex external source and appends to it.
413///
414///\param[in] E - A non-null external sema source.
415///
416void Sema::addExternalSource(ExternalSemaSource *E) {
417 assert(E && "Cannot use with NULL ptr")((E && "Cannot use with NULL ptr") ? static_cast<void
> (0) : __assert_fail ("E && \"Cannot use with NULL ptr\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 417, __PRETTY_FUNCTION__))
;
418
419 if (!ExternalSource) {
420 ExternalSource = E;
421 return;
422 }
423
424 if (isMultiplexExternalSource)
425 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
426 else {
427 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
428 isMultiplexExternalSource = true;
429 }
430}
431
432/// Print out statistics about the semantic analysis.
433void Sema::PrintStats() const {
434 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
435 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
436
437 BumpAlloc.PrintStats();
438 AnalysisWarnings.PrintStats();
439}
440
441void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
442 QualType SrcType,
443 SourceLocation Loc) {
444 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
445 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
446 return;
447
448 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
449 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
450 return;
451
452 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
453}
454
455void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
456 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
457 E->getBeginLoc()))
458 return;
459 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
460 if (!getLangOpts().CPlusPlus11)
461 return;
462
463 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
464 return;
465 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
466 return;
467
468 // If it is a macro from system header, and if the macro name is not "NULL",
469 // do not warn.
470 SourceLocation MaybeMacroLoc = E->getBeginLoc();
471 if (Diags.getSuppressSystemWarnings() &&
472 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
473 !findMacroSpelling(MaybeMacroLoc, "NULL"))
474 return;
475
476 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
477 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
478}
479
480/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
481/// If there is already an implicit cast, merge into the existing one.
482/// The result is of the given category.
483ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
484 CastKind Kind, ExprValueKind VK,
485 const CXXCastPath *BasePath,
486 CheckedConversionKind CCK) {
487#ifndef NDEBUG
488 if (VK == VK_RValue && !E->isRValue()) {
489 switch (Kind) {
490 default:
491 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "::llvm::llvm_unreachable_internal("can't implicitly cast lvalue to rvalue with this cast "
"kind", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 492)
492 "kind")::llvm::llvm_unreachable_internal("can't implicitly cast lvalue to rvalue with this cast "
"kind", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 492)
;
493 case CK_LValueToRValue:
494 case CK_ArrayToPointerDecay:
495 case CK_FunctionToPointerDecay:
496 case CK_ToVoid:
497 case CK_NonAtomicToAtomic:
498 break;
499 }
500 }
501 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue")(((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"
) ? static_cast<void> (0) : __assert_fail ("(VK == VK_RValue || !E->isRValue()) && \"can't cast rvalue to lvalue\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 501, __PRETTY_FUNCTION__))
;
502#endif
503
504 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
505 diagnoseZeroToNullptrConversion(Kind, E);
506
507 QualType ExprTy = Context.getCanonicalType(E->getType());
508 QualType TypeTy = Context.getCanonicalType(Ty);
509
510 if (ExprTy == TypeTy)
511 return E;
512
513 // C++1z [conv.array]: The temporary materialization conversion is applied.
514 // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
515 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
516 E->getValueKind() == VK_RValue) {
517 // The temporary is an lvalue in C++98 and an xvalue otherwise.
518 ExprResult Materialized = CreateMaterializeTemporaryExpr(
519 E->getType(), E, !getLangOpts().CPlusPlus11);
520 if (Materialized.isInvalid())
521 return ExprError();
522 E = Materialized.get();
523 }
524
525 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
526 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
527 ImpCast->setType(Ty);
528 ImpCast->setValueKind(VK);
529 return E;
530 }
531 }
532
533 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
534}
535
536/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
537/// to the conversion from scalar type ScalarTy to the Boolean type.
538CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
539 switch (ScalarTy->getScalarTypeKind()) {
540 case Type::STK_Bool: return CK_NoOp;
541 case Type::STK_CPointer: return CK_PointerToBoolean;
542 case Type::STK_BlockPointer: return CK_PointerToBoolean;
543 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
544 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
545 case Type::STK_Integral: return CK_IntegralToBoolean;
546 case Type::STK_Floating: return CK_FloatingToBoolean;
547 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
548 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
549 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
550 }
551 llvm_unreachable("unknown scalar type kind")::llvm::llvm_unreachable_internal("unknown scalar type kind",
"/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 551)
;
552}
553
554/// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
555static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
556 if (D->getMostRecentDecl()->isUsed())
557 return true;
558
559 if (D->isExternallyVisible())
560 return true;
561
562 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
563 // If this is a function template and none of its specializations is used,
564 // we should warn.
565 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
566 for (const auto *Spec : Template->specializations())
567 if (ShouldRemoveFromUnused(SemaRef, Spec))
568 return true;
569
570 // UnusedFileScopedDecls stores the first declaration.
571 // The declaration may have become definition so check again.
572 const FunctionDecl *DeclToCheck;
573 if (FD->hasBody(DeclToCheck))
574 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
575
576 // Later redecls may add new information resulting in not having to warn,
577 // so check again.
578 DeclToCheck = FD->getMostRecentDecl();
579 if (DeclToCheck != FD)
580 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
581 }
582
583 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
584 // If a variable usable in constant expressions is referenced,
585 // don't warn if it isn't used: if the value of a variable is required
586 // for the computation of a constant expression, it doesn't make sense to
587 // warn even if the variable isn't odr-used. (isReferenced doesn't
588 // precisely reflect that, but it's a decent approximation.)
589 if (VD->isReferenced() &&
590 VD->isUsableInConstantExpressions(SemaRef->Context))
591 return true;
592
593 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
594 // If this is a variable template and none of its specializations is used,
595 // we should warn.
596 for (const auto *Spec : Template->specializations())
597 if (ShouldRemoveFromUnused(SemaRef, Spec))
598 return true;
599
600 // UnusedFileScopedDecls stores the first declaration.
601 // The declaration may have become definition so check again.
602 const VarDecl *DeclToCheck = VD->getDefinition();
603 if (DeclToCheck)
604 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
605
606 // Later redecls may add new information resulting in not having to warn,
607 // so check again.
608 DeclToCheck = VD->getMostRecentDecl();
609 if (DeclToCheck != VD)
610 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
611 }
612
613 return false;
614}
615
616static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
617 if (auto *FD = dyn_cast<FunctionDecl>(ND))
618 return FD->isExternC();
619 return cast<VarDecl>(ND)->isExternC();
620}
621
622/// Determine whether ND is an external-linkage function or variable whose
623/// type has no linkage.
624bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
625 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
626 // because we also want to catch the case where its type has VisibleNoLinkage,
627 // which does not affect the linkage of VD.
628 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
629 !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
630 !isFunctionOrVarDeclExternC(VD);
631}
632
633/// Obtains a sorted list of functions and variables that are undefined but
634/// ODR-used.
635void Sema::getUndefinedButUsed(
636 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
637 for (const auto &UndefinedUse : UndefinedButUsed) {
638 NamedDecl *ND = UndefinedUse.first;
639
640 // Ignore attributes that have become invalid.
641 if (ND->isInvalidDecl()) continue;
642
643 // __attribute__((weakref)) is basically a definition.
644 if (ND->hasAttr<WeakRefAttr>()) continue;
645
646 if (isa<CXXDeductionGuideDecl>(ND))
647 continue;
648
649 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
650 // An exported function will always be emitted when defined, so even if
651 // the function is inline, it doesn't have to be emitted in this TU. An
652 // imported function implies that it has been exported somewhere else.
653 continue;
654 }
655
656 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
657 if (FD->isDefined())
658 continue;
659 if (FD->isExternallyVisible() &&
660 !isExternalWithNoLinkageType(FD) &&
661 !FD->getMostRecentDecl()->isInlined() &&
662 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
663 continue;
664 if (FD->getBuiltinID())
665 continue;
666 } else {
667 auto *VD = cast<VarDecl>(ND);
668 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
669 continue;
670 if (VD->isExternallyVisible() &&
671 !isExternalWithNoLinkageType(VD) &&
672 !VD->getMostRecentDecl()->isInline() &&
673 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
674 continue;
675
676 // Skip VarDecls that lack formal definitions but which we know are in
677 // fact defined somewhere.
678 if (VD->isKnownToBeDefined())
679 continue;
680 }
681
682 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
683 }
684}
685
686/// checkUndefinedButUsed - Check for undefined objects with internal linkage
687/// or that are inline.
688static void checkUndefinedButUsed(Sema &S) {
689 if (S.UndefinedButUsed.empty()) return;
690
691 // Collect all the still-undefined entities with internal linkage.
692 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
693 S.getUndefinedButUsed(Undefined);
694 if (Undefined.empty()) return;
695
696 for (auto Undef : Undefined) {
697 ValueDecl *VD = cast<ValueDecl>(Undef.first);
698 SourceLocation UseLoc = Undef.second;
699
700 if (S.isExternalWithNoLinkageType(VD)) {
701 // C++ [basic.link]p8:
702 // A type without linkage shall not be used as the type of a variable
703 // or function with external linkage unless
704 // -- the entity has C language linkage
705 // -- the entity is not odr-used or is defined in the same TU
706 //
707 // As an extension, accept this in cases where the type is externally
708 // visible, since the function or variable actually can be defined in
709 // another translation unit in that case.
710 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
711 ? diag::ext_undefined_internal_type
712 : diag::err_undefined_internal_type)
713 << isa<VarDecl>(VD) << VD;
714 } else if (!VD->isExternallyVisible()) {
715 // FIXME: We can promote this to an error. The function or variable can't
716 // be defined anywhere else, so the program must necessarily violate the
717 // one definition rule.
718 S.Diag(VD->getLocation(), diag::warn_undefined_internal)
719 << isa<VarDecl>(VD) << VD;
720 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
721 (void)FD;
722 assert(FD->getMostRecentDecl()->isInlined() &&((FD->getMostRecentDecl()->isInlined() && "used object requires definition but isn't inline or internal?"
) ? static_cast<void> (0) : __assert_fail ("FD->getMostRecentDecl()->isInlined() && \"used object requires definition but isn't inline or internal?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 723, __PRETTY_FUNCTION__))
723 "used object requires definition but isn't inline or internal?")((FD->getMostRecentDecl()->isInlined() && "used object requires definition but isn't inline or internal?"
) ? static_cast<void> (0) : __assert_fail ("FD->getMostRecentDecl()->isInlined() && \"used object requires definition but isn't inline or internal?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 723, __PRETTY_FUNCTION__))
;
724 // FIXME: This is ill-formed; we should reject.
725 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
726 } else {
727 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&((cast<VarDecl>(VD)->getMostRecentDecl()->isInline
() && "used var requires definition but isn't inline or internal?"
) ? static_cast<void> (0) : __assert_fail ("cast<VarDecl>(VD)->getMostRecentDecl()->isInline() && \"used var requires definition but isn't inline or internal?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 728, __PRETTY_FUNCTION__))
728 "used var requires definition but isn't inline or internal?")((cast<VarDecl>(VD)->getMostRecentDecl()->isInline
() && "used var requires definition but isn't inline or internal?"
) ? static_cast<void> (0) : __assert_fail ("cast<VarDecl>(VD)->getMostRecentDecl()->isInline() && \"used var requires definition but isn't inline or internal?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 728, __PRETTY_FUNCTION__))
;
729 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
730 }
731 if (UseLoc.isValid())
732 S.Diag(UseLoc, diag::note_used_here);
733 }
734
735 S.UndefinedButUsed.clear();
736}
737
738void Sema::LoadExternalWeakUndeclaredIdentifiers() {
739 if (!ExternalSource)
740 return;
741
742 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
743 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
744 for (auto &WeakID : WeakIDs)
745 WeakUndeclaredIdentifiers.insert(WeakID);
746}
747
748
749typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
750
751/// Returns true, if all methods and nested classes of the given
752/// CXXRecordDecl are defined in this translation unit.
753///
754/// Should only be called from ActOnEndOfTranslationUnit so that all
755/// definitions are actually read.
756static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
757 RecordCompleteMap &MNCComplete) {
758 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
759 if (Cache != MNCComplete.end())
760 return Cache->second;
761 if (!RD->isCompleteDefinition())
762 return false;
763 bool Complete = true;
764 for (DeclContext::decl_iterator I = RD->decls_begin(),
765 E = RD->decls_end();
766 I != E && Complete; ++I) {
767 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
768 Complete = M->isDefined() || M->isDefaulted() ||
769 (M->isPure() && !isa<CXXDestructorDecl>(M));
770 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
771 // If the template function is marked as late template parsed at this
772 // point, it has not been instantiated and therefore we have not
773 // performed semantic analysis on it yet, so we cannot know if the type
774 // can be considered complete.
775 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
776 F->getTemplatedDecl()->isDefined();
777 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
778 if (R->isInjectedClassName())
779 continue;
780 if (R->hasDefinition())
781 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
782 MNCComplete);
783 else
784 Complete = false;
785 }
786 }
787 MNCComplete[RD] = Complete;
788 return Complete;
789}
790
791/// Returns true, if the given CXXRecordDecl is fully defined in this
792/// translation unit, i.e. all methods are defined or pure virtual and all
793/// friends, friend functions and nested classes are fully defined in this
794/// translation unit.
795///
796/// Should only be called from ActOnEndOfTranslationUnit so that all
797/// definitions are actually read.
798static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
799 RecordCompleteMap &RecordsComplete,
800 RecordCompleteMap &MNCComplete) {
801 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
802 if (Cache != RecordsComplete.end())
803 return Cache->second;
804 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
805 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
806 E = RD->friend_end();
807 I != E && Complete; ++I) {
808 // Check if friend classes and methods are complete.
809 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
810 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
811 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
812 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
813 else
814 Complete = false;
815 } else {
816 // Friend functions are available through the NamedDecl of FriendDecl.
817 if (const FunctionDecl *FD =
818 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
819 Complete = FD->isDefined();
820 else
821 // This is a template friend, give up.
822 Complete = false;
823 }
824 }
825 RecordsComplete[RD] = Complete;
826 return Complete;
827}
828
829void Sema::emitAndClearUnusedLocalTypedefWarnings() {
830 if (ExternalSource)
831 ExternalSource->ReadUnusedLocalTypedefNameCandidates(
832 UnusedLocalTypedefNameCandidates);
833 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
834 if (TD->isReferenced())
835 continue;
836 Diag(TD->getLocation(), diag::warn_unused_local_typedef)
837 << isa<TypeAliasDecl>(TD) << TD->getDeclName();
838 }
839 UnusedLocalTypedefNameCandidates.clear();
840}
841
842/// This is called before the very first declaration in the translation unit
843/// is parsed. Note that the ASTContext may have already injected some
844/// declarations.
845void Sema::ActOnStartOfTranslationUnit() {
846 if (getLangOpts().ModulesTS &&
847 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
848 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
849 // We start in an implied global module fragment.
850 SourceLocation StartOfTU =
851 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
852 ActOnGlobalModuleFragmentDecl(StartOfTU);
853 ModuleScopes.back().ImplicitGlobalModuleFragment = true;
854 }
855}
856
857void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
858 // No explicit actions are required at the end of the global module fragment.
859 if (Kind == TUFragmentKind::Global)
860 return;
861
862 // Transfer late parsed template instantiations over to the pending template
863 // instantiation list. During normal compilation, the late template parser
864 // will be installed and instantiating these templates will succeed.
865 //
866 // If we are building a TU prefix for serialization, it is also safe to
867 // transfer these over, even though they are not parsed. The end of the TU
868 // should be outside of any eager template instantiation scope, so when this
869 // AST is deserialized, these templates will not be parsed until the end of
870 // the combined TU.
871 PendingInstantiations.insert(PendingInstantiations.end(),
872 LateParsedInstantiations.begin(),
873 LateParsedInstantiations.end());
874 LateParsedInstantiations.clear();
875
876 // If DefinedUsedVTables ends up marking any virtual member functions it
877 // might lead to more pending template instantiations, which we then need
878 // to instantiate.
879 DefineUsedVTables();
880
881 // C++: Perform implicit template instantiations.
882 //
883 // FIXME: When we perform these implicit instantiations, we do not
884 // carefully keep track of the point of instantiation (C++ [temp.point]).
885 // This means that name lookup that occurs within the template
886 // instantiation will always happen at the end of the translation unit,
887 // so it will find some names that are not required to be found. This is
888 // valid, but we could do better by diagnosing if an instantiation uses a
889 // name that was not visible at its first point of instantiation.
890 if (ExternalSource) {
891 // Load pending instantiations from the external source.
892 SmallVector<PendingImplicitInstantiation, 4> Pending;
893 ExternalSource->ReadPendingInstantiations(Pending);
894 for (auto PII : Pending)
895 if (auto Func = dyn_cast<FunctionDecl>(PII.first))
896 Func->setInstantiationIsPending(true);
897 PendingInstantiations.insert(PendingInstantiations.begin(),
898 Pending.begin(), Pending.end());
899 }
900
901 {
902 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
903 StringRef(""));
904 PerformPendingInstantiations();
905 }
906
907 assert(LateParsedInstantiations.empty() &&((LateParsedInstantiations.empty() && "end of TU template instantiation should not create more "
"late-parsed templates") ? static_cast<void> (0) : __assert_fail
("LateParsedInstantiations.empty() && \"end of TU template instantiation should not create more \" \"late-parsed templates\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 909, __PRETTY_FUNCTION__))
908 "end of TU template instantiation should not create more "((LateParsedInstantiations.empty() && "end of TU template instantiation should not create more "
"late-parsed templates") ? static_cast<void> (0) : __assert_fail
("LateParsedInstantiations.empty() && \"end of TU template instantiation should not create more \" \"late-parsed templates\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 909, __PRETTY_FUNCTION__))
909 "late-parsed templates")((LateParsedInstantiations.empty() && "end of TU template instantiation should not create more "
"late-parsed templates") ? static_cast<void> (0) : __assert_fail
("LateParsedInstantiations.empty() && \"end of TU template instantiation should not create more \" \"late-parsed templates\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 909, __PRETTY_FUNCTION__))
;
910}
911
912/// ActOnEndOfTranslationUnit - This is called at the very end of the
913/// translation unit when EOF is reached and all but the top-level scope is
914/// popped.
915void Sema::ActOnEndOfTranslationUnit() {
916 assert(DelayedDiagnostics.getCurrentPool() == nullptr((DelayedDiagnostics.getCurrentPool() == nullptr && "reached end of translation unit with a pool attached?"
) ? static_cast<void> (0) : __assert_fail ("DelayedDiagnostics.getCurrentPool() == nullptr && \"reached end of translation unit with a pool attached?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 917, __PRETTY_FUNCTION__))
917 && "reached end of translation unit with a pool attached?")((DelayedDiagnostics.getCurrentPool() == nullptr && "reached end of translation unit with a pool attached?"
) ? static_cast<void> (0) : __assert_fail ("DelayedDiagnostics.getCurrentPool() == nullptr && \"reached end of translation unit with a pool attached?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 917, __PRETTY_FUNCTION__))
;
918
919 // If code completion is enabled, don't perform any end-of-translation-unit
920 // work.
921 if (PP.isCodeCompletionEnabled())
922 return;
923
924 // Complete translation units and modules define vtables and perform implicit
925 // instantiations. PCH files do not.
926 if (TUKind != TU_Prefix) {
927 DiagnoseUseOfUnimplementedSelectors();
928
929 ActOnEndOfTranslationUnitFragment(
930 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
931 Module::PrivateModuleFragment
932 ? TUFragmentKind::Private
933 : TUFragmentKind::Normal);
934
935 if (LateTemplateParserCleanup)
936 LateTemplateParserCleanup(OpaqueParser);
937
938 CheckDelayedMemberExceptionSpecs();
939 } else {
940 // If we are building a TU prefix for serialization, it is safe to transfer
941 // these over, even though they are not parsed. The end of the TU should be
942 // outside of any eager template instantiation scope, so when this AST is
943 // deserialized, these templates will not be parsed until the end of the
944 // combined TU.
945 PendingInstantiations.insert(PendingInstantiations.end(),
946 LateParsedInstantiations.begin(),
947 LateParsedInstantiations.end());
948 LateParsedInstantiations.clear();
949 }
950
951 DiagnoseUnterminatedPragmaPack();
952 DiagnoseUnterminatedPragmaAttribute();
953
954 // All delayed member exception specs should be checked or we end up accepting
955 // incompatible declarations.
956 assert(DelayedOverridingExceptionSpecChecks.empty())((DelayedOverridingExceptionSpecChecks.empty()) ? static_cast
<void> (0) : __assert_fail ("DelayedOverridingExceptionSpecChecks.empty()"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 956, __PRETTY_FUNCTION__))
;
957 assert(DelayedEquivalentExceptionSpecChecks.empty())((DelayedEquivalentExceptionSpecChecks.empty()) ? static_cast
<void> (0) : __assert_fail ("DelayedEquivalentExceptionSpecChecks.empty()"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 957, __PRETTY_FUNCTION__))
;
958
959 // All dllexport classes should have been processed already.
960 assert(DelayedDllExportClasses.empty())((DelayedDllExportClasses.empty()) ? static_cast<void> (
0) : __assert_fail ("DelayedDllExportClasses.empty()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 960, __PRETTY_FUNCTION__))
;
961
962 // Remove file scoped decls that turned out to be used.
963 UnusedFileScopedDecls.erase(
964 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
965 UnusedFileScopedDecls.end(),
966 [this](const DeclaratorDecl *DD) {
967 return ShouldRemoveFromUnused(this, DD);
968 }),
969 UnusedFileScopedDecls.end());
970
971 if (TUKind == TU_Prefix) {
972 // Translation unit prefixes don't need any of the checking below.
973 if (!PP.isIncrementalProcessingEnabled())
974 TUScope = nullptr;
975 return;
976 }
977
978 // Check for #pragma weak identifiers that were never declared
979 LoadExternalWeakUndeclaredIdentifiers();
980 for (auto WeakID : WeakUndeclaredIdentifiers) {
981 if (WeakID.second.getUsed())
982 continue;
983
984 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
985 LookupOrdinaryName);
986 if (PrevDecl != nullptr &&
987 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
988 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
989 << "'weak'" << ExpectedVariableOrFunction;
990 else
991 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
992 << WeakID.first;
993 }
994
995 if (LangOpts.CPlusPlus11 &&
996 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
997 CheckDelegatingCtorCycles();
998
999 if (!Diags.hasErrorOccurred()) {
1000 if (ExternalSource)
1001 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1002 checkUndefinedButUsed(*this);
1003 }
1004
1005 // A global-module-fragment is only permitted within a module unit.
1006 bool DiagnosedMissingModuleDeclaration = false;
1007 if (!ModuleScopes.empty() &&
1008 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1009 !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1010 Diag(ModuleScopes.back().BeginLoc,
1011 diag::err_module_declaration_missing_after_global_module_introducer);
1012 DiagnosedMissingModuleDeclaration = true;
1013 }
1014
1015 if (TUKind == TU_Module) {
1016 // If we are building a module interface unit, we need to have seen the
1017 // module declaration by now.
1018 if (getLangOpts().getCompilingModule() ==
1019 LangOptions::CMK_ModuleInterface &&
1020 (ModuleScopes.empty() ||
1021 !ModuleScopes.back().Module->isModulePurview()) &&
1022 !DiagnosedMissingModuleDeclaration) {
1023 // FIXME: Make a better guess as to where to put the module declaration.
1024 Diag(getSourceManager().getLocForStartOfFile(
1025 getSourceManager().getMainFileID()),
1026 diag::err_module_declaration_missing);
1027 }
1028
1029 // If we are building a module, resolve all of the exported declarations
1030 // now.
1031 if (Module *CurrentModule = PP.getCurrentModule()) {
1032 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
1033
1034 SmallVector<Module *, 2> Stack;
1035 Stack.push_back(CurrentModule);
1036 while (!Stack.empty()) {
1037 Module *Mod = Stack.pop_back_val();
1038
1039 // Resolve the exported declarations and conflicts.
1040 // FIXME: Actually complain, once we figure out how to teach the
1041 // diagnostic client to deal with complaints in the module map at this
1042 // point.
1043 ModMap.resolveExports(Mod, /*Complain=*/false);
1044 ModMap.resolveUses(Mod, /*Complain=*/false);
1045 ModMap.resolveConflicts(Mod, /*Complain=*/false);
1046
1047 // Queue the submodules, so their exports will also be resolved.
1048 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1049 }
1050 }
1051
1052 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1053 // modules when they are built, not every time they are used.
1054 emitAndClearUnusedLocalTypedefWarnings();
1055 }
1056
1057 // C99 6.9.2p2:
1058 // A declaration of an identifier for an object that has file
1059 // scope without an initializer, and without a storage-class
1060 // specifier or with the storage-class specifier static,
1061 // constitutes a tentative definition. If a translation unit
1062 // contains one or more tentative definitions for an identifier,
1063 // and the translation unit contains no external definition for
1064 // that identifier, then the behavior is exactly as if the
1065 // translation unit contains a file scope declaration of that
1066 // identifier, with the composite type as of the end of the
1067 // translation unit, with an initializer equal to 0.
1068 llvm::SmallSet<VarDecl *, 32> Seen;
1069 for (TentativeDefinitionsType::iterator
1070 T = TentativeDefinitions.begin(ExternalSource),
1071 TEnd = TentativeDefinitions.end();
1072 T != TEnd; ++T) {
1073 VarDecl *VD = (*T)->getActingDefinition();
1074
1075 // If the tentative definition was completed, getActingDefinition() returns
1076 // null. If we've already seen this variable before, insert()'s second
1077 // return value is false.
1078 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1079 continue;
1080
1081 if (const IncompleteArrayType *ArrayT
1082 = Context.getAsIncompleteArrayType(VD->getType())) {
1083 // Set the length of the array to 1 (C99 6.9.2p5).
1084 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1085 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1086 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1087 One, ArrayType::Normal, 0);
1088 VD->setType(T);
1089 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1090 diag::err_tentative_def_incomplete_type))
1091 VD->setInvalidDecl();
1092
1093 // No initialization is performed for a tentative definition.
1094 CheckCompleteVariableDeclaration(VD);
1095
1096 // Notify the consumer that we've completed a tentative definition.
1097 if (!VD->isInvalidDecl())
1098 Consumer.CompleteTentativeDefinition(VD);
1099 }
1100
1101 // If there were errors, disable 'unused' warnings since they will mostly be
1102 // noise. Don't warn for a use from a module: either we should warn on all
1103 // file-scope declarations in modules or not at all, but whether the
1104 // declaration is used is immaterial.
1105 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1106 // Output warning for unused file scoped decls.
1107 for (UnusedFileScopedDeclsType::iterator
1108 I = UnusedFileScopedDecls.begin(ExternalSource),
1109 E = UnusedFileScopedDecls.end(); I != E; ++I) {
1110 if (ShouldRemoveFromUnused(this, *I))
1111 continue;
1112
1113 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1114 const FunctionDecl *DiagD;
1115 if (!FD->hasBody(DiagD))
1116 DiagD = FD;
1117 if (DiagD->isDeleted())
1118 continue; // Deleted functions are supposed to be unused.
1119 if (DiagD->isReferenced()) {
1120 if (isa<CXXMethodDecl>(DiagD))
1121 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1122 << DiagD->getDeclName();
1123 else {
1124 if (FD->getStorageClass() == SC_Static &&
1125 !FD->isInlineSpecified() &&
1126 !SourceMgr.isInMainFile(
1127 SourceMgr.getExpansionLoc(FD->getLocation())))
1128 Diag(DiagD->getLocation(),
1129 diag::warn_unneeded_static_internal_decl)
1130 << DiagD->getDeclName();
1131 else
1132 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1133 << /*function*/0 << DiagD->getDeclName();
1134 }
1135 } else {
1136 if (FD->getDescribedFunctionTemplate())
1137 Diag(DiagD->getLocation(), diag::warn_unused_template)
1138 << /*function*/0 << DiagD->getDeclName();
1139 else
1140 Diag(DiagD->getLocation(),
1141 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1142 : diag::warn_unused_function)
1143 << DiagD->getDeclName();
1144 }
1145 } else {
1146 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1147 if (!DiagD)
1148 DiagD = cast<VarDecl>(*I);
1149 if (DiagD->isReferenced()) {
1150 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1151 << /*variable*/1 << DiagD->getDeclName();
1152 } else if (DiagD->getType().isConstQualified()) {
1153 const SourceManager &SM = SourceMgr;
1154 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1155 !PP.getLangOpts().IsHeaderFile)
1156 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1157 << DiagD->getDeclName();
1158 } else {
1159 if (DiagD->getDescribedVarTemplate())
1160 Diag(DiagD->getLocation(), diag::warn_unused_template)
1161 << /*variable*/1 << DiagD->getDeclName();
1162 else
1163 Diag(DiagD->getLocation(), diag::warn_unused_variable)
1164 << DiagD->getDeclName();
1165 }
1166 }
1167 }
1168
1169 emitAndClearUnusedLocalTypedefWarnings();
1170 }
1171
1172 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1173 // FIXME: Load additional unused private field candidates from the external
1174 // source.
1175 RecordCompleteMap RecordsComplete;
1176 RecordCompleteMap MNCComplete;
1177 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1178 E = UnusedPrivateFields.end(); I != E; ++I) {
1179 const NamedDecl *D = *I;
1180 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1181 if (RD && !RD->isUnion() &&
1182 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1183 Diag(D->getLocation(), diag::warn_unused_private_field)
1184 << D->getDeclName();
1185 }
1186 }
1187 }
1188
1189 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1190 if (ExternalSource)
1191 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1192 for (const auto &DeletedFieldInfo : DeleteExprs) {
1193 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1194 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1195 DeleteExprLoc.second);
1196 }
1197 }
1198 }
1199
1200 // Check we've noticed that we're no longer parsing the initializer for every
1201 // variable. If we miss cases, then at best we have a performance issue and
1202 // at worst a rejects-valid bug.
1203 assert(ParsingInitForAutoVars.empty() &&((ParsingInitForAutoVars.empty() && "Didn't unmark var as having its initializer parsed"
) ? static_cast<void> (0) : __assert_fail ("ParsingInitForAutoVars.empty() && \"Didn't unmark var as having its initializer parsed\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1204, __PRETTY_FUNCTION__))
1204 "Didn't unmark var as having its initializer parsed")((ParsingInitForAutoVars.empty() && "Didn't unmark var as having its initializer parsed"
) ? static_cast<void> (0) : __assert_fail ("ParsingInitForAutoVars.empty() && \"Didn't unmark var as having its initializer parsed\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1204, __PRETTY_FUNCTION__))
;
1205
1206 if (!PP.isIncrementalProcessingEnabled())
1207 TUScope = nullptr;
1208}
1209
1210
1211//===----------------------------------------------------------------------===//
1212// Helper functions.
1213//===----------------------------------------------------------------------===//
1214
1215DeclContext *Sema::getFunctionLevelDeclContext() {
1216 DeclContext *DC = CurContext;
1217
1218 while (true) {
1219 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1220 DC = DC->getParent();
1221 } else if (isa<CXXMethodDecl>(DC) &&
1222 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1223 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1224 DC = DC->getParent()->getParent();
1225 }
1226 else break;
1227 }
1228
1229 return DC;
1230}
1231
1232/// getCurFunctionDecl - If inside of a function body, this returns a pointer
1233/// to the function decl for the function being parsed. If we're currently
1234/// in a 'block', this returns the containing context.
1235FunctionDecl *Sema::getCurFunctionDecl() {
1236 DeclContext *DC = getFunctionLevelDeclContext();
1237 return dyn_cast<FunctionDecl>(DC);
1238}
1239
1240ObjCMethodDecl *Sema::getCurMethodDecl() {
1241 DeclContext *DC = getFunctionLevelDeclContext();
1242 while (isa<RecordDecl>(DC))
1243 DC = DC->getParent();
1244 return dyn_cast<ObjCMethodDecl>(DC);
1245}
1246
1247NamedDecl *Sema::getCurFunctionOrMethodDecl() {
1248 DeclContext *DC = getFunctionLevelDeclContext();
1249 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1250 return cast<NamedDecl>(DC);
1251 return nullptr;
1252}
1253
1254void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1255 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1256 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1257 // been made more painfully obvious by the refactor that introduced this
1258 // function, but it is possible that the incoming argument can be
1259 // eliminated. If it truly cannot be (for example, there is some reentrancy
1260 // issue I am not seeing yet), then there should at least be a clarifying
1261 // comment somewhere.
1262 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
1263 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1264 Diags.getCurrentDiagID())) {
1265 case DiagnosticIDs::SFINAE_Report:
1266 // We'll report the diagnostic below.
1267 break;
1268
1269 case DiagnosticIDs::SFINAE_SubstitutionFailure:
1270 // Count this failure so that we know that template argument deduction
1271 // has failed.
1272 ++NumSFINAEErrors;
1273
1274 // Make a copy of this suppressed diagnostic and store it with the
1275 // template-deduction information.
1276 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1277 Diagnostic DiagInfo(&Diags);
1278 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1279 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1280 }
1281
1282 Diags.setLastDiagnosticIgnored();
1283 Diags.Clear();
1284 return;
1285
1286 case DiagnosticIDs::SFINAE_AccessControl: {
1287 // Per C++ Core Issue 1170, access control is part of SFINAE.
1288 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1289 // make access control a part of SFINAE for the purposes of checking
1290 // type traits.
1291 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
1292 break;
1293
1294 SourceLocation Loc = Diags.getCurrentDiagLoc();
1295
1296 // Suppress this diagnostic.
1297 ++NumSFINAEErrors;
1298
1299 // Make a copy of this suppressed diagnostic and store it with the
1300 // template-deduction information.
1301 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1302 Diagnostic DiagInfo(&Diags);
1303 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1304 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1305 }
1306
1307 Diags.setLastDiagnosticIgnored();
1308 Diags.Clear();
1309
1310 // Now the diagnostic state is clear, produce a C++98 compatibility
1311 // warning.
1312 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1313
1314 // The last diagnostic which Sema produced was ignored. Suppress any
1315 // notes attached to it.
1316 Diags.setLastDiagnosticIgnored();
1317 return;
1318 }
1319
1320 case DiagnosticIDs::SFINAE_Suppress:
1321 // Make a copy of this suppressed diagnostic and store it with the
1322 // template-deduction information;
1323 if (*Info) {
1324 Diagnostic DiagInfo(&Diags);
1325 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1326 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1327 }
1328
1329 // Suppress this diagnostic.
1330 Diags.setLastDiagnosticIgnored();
1331 Diags.Clear();
1332 return;
1333 }
1334 }
1335
1336 // Copy the diagnostic printing policy over the ASTContext printing policy.
1337 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1338 Context.setPrintingPolicy(getPrintingPolicy());
1339
1340 // Emit the diagnostic.
1341 if (!Diags.EmitCurrentDiagnostic())
1342 return;
1343
1344 // If this is not a note, and we're in a template instantiation
1345 // that is different from the last template instantiation where
1346 // we emitted an error, print a template instantiation
1347 // backtrace.
1348 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1349 PrintContextStack();
1350}
1351
1352Sema::SemaDiagnosticBuilder
1353Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1354 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1355 PD.Emit(Builder);
1356
1357 return Builder;
1358}
1359
1360// Print notes showing how we can reach FD starting from an a priori
1361// known-callable function.
1362static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1363 auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1364 while (FnIt != S.DeviceKnownEmittedFns.end()) {
1365 DiagnosticBuilder Builder(
1366 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1367 Builder << FnIt->second.FD;
1368 Builder.setForceEmit();
1369
1370 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1371 }
1372}
1373
1374// Emit any deferred diagnostics for FD and erase them from the map in which
1375// they're stored.
1376static void emitDeferredDiags(Sema &S, FunctionDecl *FD) {
1377 auto It = S.DeviceDeferredDiags.find(FD);
1378 if (It == S.DeviceDeferredDiags.end())
1379 return;
1380 bool HasWarningOrError = false;
1381 for (PartialDiagnosticAt &PDAt : It->second) {
1382 const SourceLocation &Loc = PDAt.first;
1383 const PartialDiagnostic &PD = PDAt.second;
1384 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1385 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1386 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1387 Builder.setForceEmit();
1388 PD.Emit(Builder);
1389 }
1390 S.DeviceDeferredDiags.erase(It);
1391
1392 // FIXME: Should this be called after every warning/error emitted in the loop
1393 // above, instead of just once per function? That would be consistent with
1394 // how we handle immediate errors, but it also seems like a bit much.
1395 if (HasWarningOrError)
1396 emitCallStackNotes(S, FD);
1397}
1398
1399// In CUDA, there are some constructs which may appear in semantically-valid
1400// code, but trigger errors if we ever generate code for the function in which
1401// they appear. Essentially every construct you're not allowed to use on the
1402// device falls into this category, because you are allowed to use these
1403// constructs in a __host__ __device__ function, but only if that function is
1404// never codegen'ed on the device.
1405//
1406// To handle semantic checking for these constructs, we keep track of the set of
1407// functions we know will be emitted, either because we could tell a priori that
1408// they would be emitted, or because they were transitively called by a
1409// known-emitted function.
1410//
1411// We also keep a partial call graph of which not-known-emitted functions call
1412// which other not-known-emitted functions.
1413//
1414// When we see something which is illegal if the current function is emitted
1415// (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1416// CheckCUDACall), we first check if the current function is known-emitted. If
1417// so, we immediately output the diagnostic.
1418//
1419// Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1420// until we discover that the function is known-emitted, at which point we take
1421// it out of this map and emit the diagnostic.
1422
1423Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc,
1424 unsigned DiagID, FunctionDecl *Fn,
1425 Sema &S)
1426 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1427 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1428 switch (K) {
1429 case K_Nop:
1430 break;
1431 case K_Immediate:
1432 case K_ImmediateWithCallStack:
1433 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1434 break;
1435 case K_Deferred:
1436 assert(Fn && "Must have a function to attach the deferred diag to.")((Fn && "Must have a function to attach the deferred diag to."
) ? static_cast<void> (0) : __assert_fail ("Fn && \"Must have a function to attach the deferred diag to.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1436, __PRETTY_FUNCTION__))
;
1437 auto &Diags = S.DeviceDeferredDiags[Fn];
1438 PartialDiagId.emplace(Diags.size());
1439 Diags.emplace_back(Loc, S.PDiag(DiagID));
1440 break;
1441 }
1442}
1443
1444Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D)
1445 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1446 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1447 PartialDiagId(D.PartialDiagId) {
1448 // Clean the previous diagnostics.
1449 D.ShowCallStack = false;
1450 D.ImmediateDiag.reset();
1451 D.PartialDiagId.reset();
1452}
1453
1454Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
1455 if (ImmediateDiag) {
1456 // Emit our diagnostic and, if it was a warning or error, output a callstack
1457 // if Fn isn't a priori known-emitted.
1458 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1459 DiagID, Loc) >= DiagnosticsEngine::Warning;
1460 ImmediateDiag.reset(); // Emit the immediate diag.
1461 if (IsWarningOrError && ShowCallStack)
1462 emitCallStackNotes(S, Fn);
1463 } else {
1464 assert((!PartialDiagId || ShowCallStack) &&(((!PartialDiagId || ShowCallStack) && "Must always show call stack for deferred diags."
) ? static_cast<void> (0) : __assert_fail ("(!PartialDiagId || ShowCallStack) && \"Must always show call stack for deferred diags.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1465, __PRETTY_FUNCTION__))
1465 "Must always show call stack for deferred diags.")(((!PartialDiagId || ShowCallStack) && "Must always show call stack for deferred diags."
) ? static_cast<void> (0) : __assert_fail ("(!PartialDiagId || ShowCallStack) && \"Must always show call stack for deferred diags.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1465, __PRETTY_FUNCTION__))
;
1466 }
1467}
1468
1469// Indicate that this function (and thus everything it transtively calls) will
1470// be codegen'ed, and emit any deferred diagnostics on this function and its
1471// (transitive) callees.
1472void Sema::markKnownEmitted(
1473 Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1474 SourceLocation OrigLoc,
1475 const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1476 // Nothing to do if we already know that FD is emitted.
1477 if (IsKnownEmitted(S, OrigCallee)) {
1478 assert(!S.DeviceCallGraph.count(OrigCallee))((!S.DeviceCallGraph.count(OrigCallee)) ? static_cast<void
> (0) : __assert_fail ("!S.DeviceCallGraph.count(OrigCallee)"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1478, __PRETTY_FUNCTION__))
;
1479 return;
1480 }
1481
1482 // We've just discovered that OrigCallee is known-emitted. Walk our call
1483 // graph to see what else we can now discover also must be emitted.
1484
1485 struct CallInfo {
1486 FunctionDecl *Caller;
1487 FunctionDecl *Callee;
1488 SourceLocation Loc;
1489 };
1490 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1491 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1492 Seen.insert(OrigCallee);
1493 while (!Worklist.empty()) {
1494 CallInfo C = Worklist.pop_back_val();
1495 assert(!IsKnownEmitted(S, C.Callee) &&((!IsKnownEmitted(S, C.Callee) && "Worklist should not contain known-emitted functions."
) ? static_cast<void> (0) : __assert_fail ("!IsKnownEmitted(S, C.Callee) && \"Worklist should not contain known-emitted functions.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1496, __PRETTY_FUNCTION__))
1496 "Worklist should not contain known-emitted functions.")((!IsKnownEmitted(S, C.Callee) && "Worklist should not contain known-emitted functions."
) ? static_cast<void> (0) : __assert_fail ("!IsKnownEmitted(S, C.Callee) && \"Worklist should not contain known-emitted functions.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1496, __PRETTY_FUNCTION__))
;
1497 S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1498 emitDeferredDiags(S, C.Callee);
1499
1500 // If this is a template instantiation, explore its callgraph as well:
1501 // Non-dependent calls are part of the template's callgraph, while dependent
1502 // calls are part of to the instantiation's call graph.
1503 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1504 FunctionDecl *TemplFD = Templ->getAsFunction();
1505 if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1506 Seen.insert(TemplFD);
1507 Worklist.push_back(
1508 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1509 }
1510 }
1511
1512 // Add all functions called by Callee to our worklist.
1513 auto CGIt = S.DeviceCallGraph.find(C.Callee);
1514 if (CGIt == S.DeviceCallGraph.end())
1515 continue;
1516
1517 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1518 CGIt->second) {
1519 FunctionDecl *NewCallee = FDLoc.first;
1520 SourceLocation CallLoc = FDLoc.second;
1521 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1522 continue;
1523 Seen.insert(NewCallee);
1524 Worklist.push_back(
1525 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1526 }
1527
1528 // C.Callee is now known-emitted, so we no longer need to maintain its list
1529 // of callees in DeviceCallGraph.
1530 S.DeviceCallGraph.erase(CGIt);
1531 }
1532}
1533
1534Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
1535 if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)
1536 return diagIfOpenMPDeviceCode(Loc, DiagID);
1537 if (getLangOpts().CUDA)
1538 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1539 : CUDADiagIfHostCode(Loc, DiagID);
1540 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID,
1541 getCurFunctionDecl(), *this);
1542}
1543
1544/// Looks through the macro-expansion chain for the given
1545/// location, looking for a macro expansion with the given name.
1546/// If one is found, returns true and sets the location to that
1547/// expansion loc.
1548bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1549 SourceLocation loc = locref;
1550 if (!loc.isMacroID()) return false;
1551
1552 // There's no good way right now to look at the intermediate
1553 // expansions, so just jump to the expansion location.
1554 loc = getSourceManager().getExpansionLoc(loc);
1555
1556 // If that's written with the name, stop here.
1557 SmallVector<char, 16> buffer;
1558 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1559 locref = loc;
1560 return true;
1561 }
1562 return false;
1563}
1564
1565/// Determines the active Scope associated with the given declaration
1566/// context.
1567///
1568/// This routine maps a declaration context to the active Scope object that
1569/// represents that declaration context in the parser. It is typically used
1570/// from "scope-less" code (e.g., template instantiation, lazy creation of
1571/// declarations) that injects a name for name-lookup purposes and, therefore,
1572/// must update the Scope.
1573///
1574/// \returns The scope corresponding to the given declaraion context, or NULL
1575/// if no such scope is open.
1576Scope *Sema::getScopeForContext(DeclContext *Ctx) {
1577
1578 if (!Ctx)
1579 return nullptr;
1580
1581 Ctx = Ctx->getPrimaryContext();
1582 for (Scope *S = getCurScope(); S; S = S->getParent()) {
1583 // Ignore scopes that cannot have declarations. This is important for
1584 // out-of-line definitions of static class members.
1585 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1586 if (DeclContext *Entity = S->getEntity())
1587 if (Ctx == Entity->getPrimaryContext())
1588 return S;
1589 }
1590
1591 return nullptr;
1592}
1593
1594/// Enter a new function scope
1595void Sema::PushFunctionScope() {
1596 if (FunctionScopes.empty() && CachedFunctionScope) {
1597 // Use CachedFunctionScope to avoid allocating memory when possible.
1598 CachedFunctionScope->Clear();
1599 FunctionScopes.push_back(CachedFunctionScope.release());
1600 } else {
1601 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1602 }
1603 if (LangOpts.OpenMP)
1604 pushOpenMPFunctionRegion();
1605}
1606
1607void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1608 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1609 BlockScope, Block));
1610}
1611
1612LambdaScopeInfo *Sema::PushLambdaScope() {
1613 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1614 FunctionScopes.push_back(LSI);
1615 return LSI;
1616}
1617
1618void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1619 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1620 LSI->AutoTemplateParameterDepth = Depth;
1621 return;
1622 }
1623 llvm_unreachable(::llvm::llvm_unreachable_internal("Remove assertion if intentionally called in a non-lambda context."
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1624)
1624 "Remove assertion if intentionally called in a non-lambda context.")::llvm::llvm_unreachable_internal("Remove assertion if intentionally called in a non-lambda context."
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1624)
;
1625}
1626
1627// Check that the type of the VarDecl has an accessible copy constructor and
1628// resolve its destructor's exception specification.
1629static void checkEscapingByref(VarDecl *VD, Sema &S) {
1630 QualType T = VD->getType();
1631 EnterExpressionEvaluationContext scope(
1632 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1633 SourceLocation Loc = VD->getLocation();
1634 Expr *VarRef =
1635 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1636 ExprResult Result = S.PerformMoveOrCopyInitialization(
1637 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1638 VarRef, /*AllowNRVO=*/true);
1639 if (!Result.isInvalid()) {
1640 Result = S.MaybeCreateExprWithCleanups(Result);
1641 Expr *Init = Result.getAs<Expr>();
1642 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1643 }
1644
1645 // The destructor's exception specification is needed when IRGen generates
1646 // block copy/destroy functions. Resolve it here.
1647 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1648 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1649 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1650 S.ResolveExceptionSpec(Loc, FPT);
1651 }
1652}
1653
1654static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1655 // Set the EscapingByref flag of __block variables captured by
1656 // escaping blocks.
1657 for (const BlockDecl *BD : FSI.Blocks) {
1658 if (BD->doesNotEscape())
1659 continue;
1660 for (const BlockDecl::Capture &BC : BD->captures()) {
1661 VarDecl *VD = BC.getVariable();
1662 if (VD->hasAttr<BlocksAttr>())
1663 VD->setEscapingByref();
1664 }
1665 }
1666
1667 for (VarDecl *VD : FSI.ByrefBlockVars) {
1668 // __block variables might require us to capture a copy-initializer.
1669 if (!VD->isEscapingByref())
1670 continue;
1671 // It's currently invalid to ever have a __block variable with an
1672 // array type; should we diagnose that here?
1673 // Regardless, we don't want to ignore array nesting when
1674 // constructing this copy.
1675 if (VD->getType()->isStructureOrClassType())
1676 checkEscapingByref(VD, S);
1677 }
1678}
1679
1680/// Pop a function (or block or lambda or captured region) scope from the stack.
1681///
1682/// \param WP The warning policy to use for CFG-based warnings, or null if such
1683/// warnings should not be produced.
1684/// \param D The declaration corresponding to this function scope, if producing
1685/// CFG-based warnings.
1686/// \param BlockType The type of the block expression, if D is a BlockDecl.
1687Sema::PoppedFunctionScopePtr
1688Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1689 const Decl *D, QualType BlockType) {
1690 assert(!FunctionScopes.empty() && "mismatched push/pop!")((!FunctionScopes.empty() && "mismatched push/pop!") ?
static_cast<void> (0) : __assert_fail ("!FunctionScopes.empty() && \"mismatched push/pop!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1690, __PRETTY_FUNCTION__))
;
1691
1692 markEscapingByrefs(*FunctionScopes.back(), *this);
1693
1694 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),
1695 PoppedFunctionScopeDeleter(this));
1696
1697 if (LangOpts.OpenMP)
1698 popOpenMPFunctionRegion(Scope.get());
1699
1700 // Issue any analysis-based warnings.
1701 if (WP && D)
1702 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
1703 else
1704 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1705 Diag(PUD.Loc, PUD.PD);
1706
1707 return Scope;
1708}
1709
1710void Sema::PoppedFunctionScopeDeleter::
1711operator()(sema::FunctionScopeInfo *Scope) const {
1712 // Stash the function scope for later reuse if it's for a normal function.
1713 if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1714 Self->CachedFunctionScope.reset(Scope);
1715 else
1716 delete Scope;
1717}
1718
1719void Sema::PushCompoundScope(bool IsStmtExpr) {
1720 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1721}
1722
1723void Sema::PopCompoundScope() {
1724 FunctionScopeInfo *CurFunction = getCurFunction();
1725 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop")((!CurFunction->CompoundScopes.empty() && "mismatched push/pop"
) ? static_cast<void> (0) : __assert_fail ("!CurFunction->CompoundScopes.empty() && \"mismatched push/pop\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1725, __PRETTY_FUNCTION__))
;
1726
1727 CurFunction->CompoundScopes.pop_back();
1728}
1729
1730/// Determine whether any errors occurred within this function/method/
1731/// block.
1732bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1733 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1734}
1735
1736void Sema::setFunctionHasBranchIntoScope() {
1737 if (!FunctionScopes.empty())
1738 FunctionScopes.back()->setHasBranchIntoScope();
1739}
1740
1741void Sema::setFunctionHasBranchProtectedScope() {
1742 if (!FunctionScopes.empty())
1743 FunctionScopes.back()->setHasBranchProtectedScope();
1744}
1745
1746void Sema::setFunctionHasIndirectGoto() {
1747 if (!FunctionScopes.empty())
1748 FunctionScopes.back()->setHasIndirectGoto();
1749}
1750
1751BlockScopeInfo *Sema::getCurBlock() {
1752 if (FunctionScopes.empty())
1753 return nullptr;
1754
1755 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1756 if (CurBSI && CurBSI->TheDecl &&
1757 !CurBSI->TheDecl->Encloses(CurContext)) {
1758 // We have switched contexts due to template instantiation.
1759 assert(!CodeSynthesisContexts.empty())((!CodeSynthesisContexts.empty()) ? static_cast<void> (
0) : __assert_fail ("!CodeSynthesisContexts.empty()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1759, __PRETTY_FUNCTION__))
;
1760 return nullptr;
1761 }
1762
1763 return CurBSI;
1764}
1765
1766FunctionScopeInfo *Sema::getEnclosingFunction() const {
1767 if (FunctionScopes.empty())
1768 return nullptr;
1769
1770 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1771 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1772 continue;
1773 return FunctionScopes[e];
1774 }
1775 return nullptr;
1776}
1777
1778LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1779 if (FunctionScopes.empty())
1780 return nullptr;
1781
1782 auto I = FunctionScopes.rbegin();
1783 if (IgnoreNonLambdaCapturingScope) {
1784 auto E = FunctionScopes.rend();
1785 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1786 ++I;
1787 if (I == E)
1788 return nullptr;
1789 }
1790 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1791 if (CurLSI && CurLSI->Lambda &&
1792 !CurLSI->Lambda->Encloses(CurContext)) {
1793 // We have switched contexts due to template instantiation.
1794 assert(!CodeSynthesisContexts.empty())((!CodeSynthesisContexts.empty()) ? static_cast<void> (
0) : __assert_fail ("!CodeSynthesisContexts.empty()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1794, __PRETTY_FUNCTION__))
;
1795 return nullptr;
1796 }
1797
1798 return CurLSI;
1799}
1800// We have a generic lambda if we parsed auto parameters, or we have
1801// an associated template parameter list.
1802LambdaScopeInfo *Sema::getCurGenericLambda() {
1803 if (LambdaScopeInfo *LSI = getCurLambda()) {
1804 return (LSI->TemplateParams.size() ||
1805 LSI->GLTemplateParameterList) ? LSI : nullptr;
1806 }
1807 return nullptr;
1808}
1809
1810
1811void Sema::ActOnComment(SourceRange Comment) {
1812 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1813 SourceMgr.isInSystemHeader(Comment.getBegin()))
1814 return;
1815 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1816 if (RC.isAlmostTrailingComment()) {
1817 SourceRange MagicMarkerRange(Comment.getBegin(),
1818 Comment.getBegin().getLocWithOffset(3));
1819 StringRef MagicMarkerText;
1820 switch (RC.getKind()) {
1821 case RawComment::RCK_OrdinaryBCPL:
1822 MagicMarkerText = "///<";
1823 break;
1824 case RawComment::RCK_OrdinaryC:
1825 MagicMarkerText = "/**<";
1826 break;
1827 default:
1828 llvm_unreachable("if this is an almost Doxygen comment, "::llvm::llvm_unreachable_internal("if this is an almost Doxygen comment, "
"it should be ordinary", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1829)
1829 "it should be ordinary")::llvm::llvm_unreachable_internal("if this is an almost Doxygen comment, "
"it should be ordinary", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/Sema.cpp"
, 1829)
;
1830 }
1831 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1832 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1833 }
1834 Context.addComment(RC);
1835}
1836
1837// Pin this vtable to this file.
1838ExternalSemaSource::~ExternalSemaSource() {}
1839
1840void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1841void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
1842
1843void ExternalSemaSource::ReadKnownNamespaces(
1844 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1845}
1846
1847void ExternalSemaSource::ReadUndefinedButUsed(
1848 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1849
1850void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1851 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1852
1853/// Figure out if an expression could be turned into a call.
1854///
1855/// Use this when trying to recover from an error where the programmer may have
1856/// written just the name of a function instead of actually calling it.
1857///
1858/// \param E - The expression to examine.
1859/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1860/// with no arguments, this parameter is set to the type returned by such a
1861/// call; otherwise, it is set to an empty QualType.
1862/// \param OverloadSet - If the expression is an overloaded function
1863/// name, this parameter is populated with the decls of the various overloads.
1864bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1865 UnresolvedSetImpl &OverloadSet) {
1866 ZeroArgCallReturnTy = QualType();
1867 OverloadSet.clear();
1868
1869 const OverloadExpr *Overloads = nullptr;
1870 bool IsMemExpr = false;
1871 if (E.getType() == Context.OverloadTy) {
1872 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1873
1874 // Ignore overloads that are pointer-to-member constants.
1875 if (FR.HasFormOfMemberPointer)
1876 return false;
1877
1878 Overloads = FR.Expression;
1879 } else if (E.getType() == Context.BoundMemberTy) {
1880 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1881 IsMemExpr = true;
1882 }
1883
1884 bool Ambiguous = false;
1885 bool IsMV = false;
1886
1887 if (Overloads) {
1888 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1889 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1890 OverloadSet.addDecl(*it);
1891
1892 // Check whether the function is a non-template, non-member which takes no
1893 // arguments.
1894 if (IsMemExpr)
1895 continue;
1896 if (const FunctionDecl *OverloadDecl
1897 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1898 if (OverloadDecl->getMinRequiredArguments() == 0) {
1899 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1900 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1901 OverloadDecl->isCPUSpecificMultiVersion()))) {
1902 ZeroArgCallReturnTy = QualType();
1903 Ambiguous = true;
1904 } else {
1905 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1906 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1907 OverloadDecl->isCPUSpecificMultiVersion();
1908 }
1909 }
1910 }
1911 }
1912
1913 // If it's not a member, use better machinery to try to resolve the call
1914 if (!IsMemExpr)
1915 return !ZeroArgCallReturnTy.isNull();
1916 }
1917
1918 // Attempt to call the member with no arguments - this will correctly handle
1919 // member templates with defaults/deduction of template arguments, overloads
1920 // with default arguments, etc.
1921 if (IsMemExpr && !E.isTypeDependent()) {
1922 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1923 getDiagnostics().setSuppressAllDiagnostics(true);
1924 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1925 None, SourceLocation());
1926 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1927 if (R.isUsable()) {
1928 ZeroArgCallReturnTy = R.get()->getType();
1929 return true;
1930 }
1931 return false;
1932 }
1933
1934 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1935 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1936 if (Fun->getMinRequiredArguments() == 0)
1937 ZeroArgCallReturnTy = Fun->getReturnType();
1938 return true;
1939 }
1940 }
1941
1942 // We don't have an expression that's convenient to get a FunctionDecl from,
1943 // but we can at least check if the type is "function of 0 arguments".
1944 QualType ExprTy = E.getType();
1945 const FunctionType *FunTy = nullptr;
1946 QualType PointeeTy = ExprTy->getPointeeType();
1947 if (!PointeeTy.isNull())
1948 FunTy = PointeeTy->getAs<FunctionType>();
1949 if (!FunTy)
1950 FunTy = ExprTy->getAs<FunctionType>();
1951
1952 if (const FunctionProtoType *FPT =
1953 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1954 if (FPT->getNumParams() == 0)
1955 ZeroArgCallReturnTy = FunTy->getReturnType();
1956 return true;
1957 }
1958 return false;
1959}
1960
1961/// Give notes for a set of overloads.
1962///
1963/// A companion to tryExprAsCall. In cases when the name that the programmer
1964/// wrote was an overloaded function, we may be able to make some guesses about
1965/// plausible overloads based on their return types; such guesses can be handed
1966/// off to this method to be emitted as notes.
1967///
1968/// \param Overloads - The overloads to note.
1969/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1970/// -fshow-overloads=best, this is the location to attach to the note about too
1971/// many candidates. Typically this will be the location of the original
1972/// ill-formed expression.
1973static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1974 const SourceLocation FinalNoteLoc) {
1975 int ShownOverloads = 0;
1976 int SuppressedOverloads = 0;
1977 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1978 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1979 // FIXME: Magic number for max shown overloads stolen from
1980 // OverloadCandidateSet::NoteCandidates.
1981 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1982 ++SuppressedOverloads;
1983 continue;
1984 }
1985
1986 NamedDecl *Fn = (*It)->getUnderlyingDecl();
1987 // Don't print overloads for non-default multiversioned functions.
1988 if (const auto *FD = Fn->getAsFunction()) {
1989 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1990 !FD->getAttr<TargetAttr>()->isDefaultVersion())
1991 continue;
1992 }
1993 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1994 ++ShownOverloads;
1995 }
1996
1997 if (SuppressedOverloads)
1998 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1999 << SuppressedOverloads;
2000}
2001
2002static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
2003 const UnresolvedSetImpl &Overloads,
2004 bool (*IsPlausibleResult)(QualType)) {
2005 if (!IsPlausibleResult)
2006 return noteOverloads(S, Overloads, Loc);
2007
2008 UnresolvedSet<2> PlausibleOverloads;
2009 for (OverloadExpr::decls_iterator It = Overloads.begin(),
2010 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2011 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2012 QualType OverloadResultTy = OverloadDecl->getReturnType();
2013 if (IsPlausibleResult(OverloadResultTy))
2014 PlausibleOverloads.addDecl(It.getDecl());
2015 }
2016 noteOverloads(S, PlausibleOverloads, Loc);
2017}
2018
2019/// Determine whether the given expression can be called by just
2020/// putting parentheses after it. Notably, expressions with unary
2021/// operators can't be because the unary operator will start parsing
2022/// outside the call.
2023static bool IsCallableWithAppend(Expr *E) {
2024 E = E->IgnoreImplicit();
2025 return (!isa<CStyleCastExpr>(E) &&
2026 !isa<UnaryOperator>(E) &&
2027 !isa<BinaryOperator>(E) &&
2028 !isa<CXXOperatorCallExpr>(E));
2029}
2030
2031static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2032 if (const auto *UO = dyn_cast<UnaryOperator>(E))
2033 E = UO->getSubExpr();
2034
2035 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2036 if (ULE->getNumDecls() == 0)
2037 return false;
2038
2039 const NamedDecl *ND = *ULE->decls_begin();
2040 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2041 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2042 }
2043 return false;
2044}
2045
2046bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2047 bool ForceComplain,
2048 bool (*IsPlausibleResult)(QualType)) {
2049 SourceLocation Loc = E.get()->getExprLoc();
2050 SourceRange Range = E.get()->getSourceRange();
2051
2052 QualType ZeroArgCallTy;
2053 UnresolvedSet<4> Overloads;
2054 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2055 !ZeroArgCallTy.isNull() &&
2056 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2057 // At this point, we know E is potentially callable with 0
2058 // arguments and that it returns something of a reasonable type,
2059 // so we can emit a fixit and carry on pretending that E was
2060 // actually a CallExpr.
2061 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2062 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2063 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2064 << (IsCallableWithAppend(E.get())
2065 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2066 : FixItHint());
2067 if (!IsMV)
2068 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2069
2070 // FIXME: Try this before emitting the fixit, and suppress diagnostics
2071 // while doing so.
2072 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2073 Range.getEnd().getLocWithOffset(1));
2074 return true;
2075 }
2076
2077 if (!ForceComplain) return false;
2078
2079 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2080 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2081 if (!IsMV)
2082 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2083 E = ExprError();
2084 return true;
2085}
2086
2087IdentifierInfo *Sema::getSuperIdentifier() const {
2088 if (!Ident_super)
2089 Ident_super = &Context.Idents.get("super");
2090 return Ident_super;
2091}
2092
2093IdentifierInfo *Sema::getFloat128Identifier() const {
2094 if (!Ident___float128)
2095 Ident___float128 = &Context.Idents.get("__float128");
2096 return Ident___float128;
2097}
2098
2099void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
2100 CapturedRegionKind K) {
2101 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
2102 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2103 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
2104 CSI->ReturnType = Context.VoidTy;
2105 FunctionScopes.push_back(CSI);
2106}
2107
2108CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
2109 if (FunctionScopes.empty())
2110 return nullptr;
2111
2112 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2113}
2114
2115const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2116Sema::getMismatchingDeleteExpressions() const {
2117 return DeleteExprs;
2118}
2119
2120void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2121 if (ExtStr.empty())
2122 return;
2123 llvm::SmallVector<StringRef, 1> Exts;
2124 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2125 auto CanT = T.getCanonicalType().getTypePtr();
2126 for (auto &I : Exts)
2127 OpenCLTypeExtMap[CanT].insert(I.str());
2128}
2129
2130void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2131 llvm::SmallVector<StringRef, 1> Exts;
2132 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2133 if (Exts.empty())
2134 return;
2135 for (auto &I : Exts)
2136 OpenCLDeclExtMap[FD].insert(I.str());
2137}
2138
2139void Sema::setCurrentOpenCLExtensionForType(QualType T) {
2140 if (CurrOpenCLExtension.empty())
2141 return;
2142 setOpenCLExtensionForType(T, CurrOpenCLExtension);
2143}
2144
2145void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
2146 if (CurrOpenCLExtension.empty())
2147 return;
2148 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2149}
2150
2151std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
2152 if (!OpenCLDeclExtMap.empty())
2153 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2154
2155 return "";
2156}
2157
2158std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
2159 if (!OpenCLTypeExtMap.empty())
2160 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2161
2162 return "";
2163}
2164
2165template <typename T, typename MapT>
2166std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2167 std::string ExtensionNames = "";
2168 auto Loc = Map.find(FDT);
2169
2170 for (auto const& I : Loc->second) {
2171 ExtensionNames += I;
2172 ExtensionNames += " ";
2173 }
2174 ExtensionNames.pop_back();
2175
2176 return ExtensionNames;
2177}
2178
2179bool Sema::isOpenCLDisabledDecl(Decl *FD) {
2180 auto Loc = OpenCLDeclExtMap.find(FD);
2181 if (Loc == OpenCLDeclExtMap.end())
2182 return false;
2183 for (auto &I : Loc->second) {
2184 if (!getOpenCLOptions().isEnabled(I))
2185 return true;
2186 }
2187 return false;
2188}
2189
2190template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2191bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2192 DiagInfoT DiagInfo, MapT &Map,
2193 unsigned Selector,
2194 SourceRange SrcRange) {
2195 auto Loc = Map.find(D);
2196 if (Loc == Map.end())
2197 return false;
2198 bool Disabled = false;
2199 for (auto &I : Loc->second) {
2200 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2201 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2202 << I << SrcRange;
2203 Disabled = true;
2204 }
2205 }
2206 return Disabled;
2207}
2208
2209bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
2210 // Check extensions for declared types.
2211 Decl *Decl = nullptr;
2212 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2213 Decl = TypedefT->getDecl();
2214 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2215 Decl = TagT->getDecl();
2216 auto Loc = DS.getTypeSpecTypeLoc();
2217
2218 // Check extensions for vector types.
2219 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2220 if (QT->isExtVectorType()) {
2221 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2222 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2223 }
2224
2225 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2226 return true;
2227
2228 // Check extensions for builtin types.
2229 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2230 QT, OpenCLTypeExtMap);
2231}
2232
2233bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2234 IdentifierInfo *FnName = D.getIdentifier();
2235 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2236 OpenCLDeclExtMap, 1, D.getSourceRange());
2237}

/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Attribute classes' definitions *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifndef LLVM_CLANG_ATTR_CLASSES_INC
10#define LLVM_CLANG_ATTR_CLASSES_INC
11
12class AArch64VectorPcsAttr : public InheritableAttr {
13public:
14 static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
15 auto *A = new (Ctx) AArch64VectorPcsAttr(Loc, Ctx, 0);
16 A->setImplicit(true);
17 return A;
18 }
19
20 AArch64VectorPcsAttr(SourceRange R, ASTContext &Ctx
21 , unsigned SI
22 )
23 : InheritableAttr(attr::AArch64VectorPcs, R, SI, false, false)
24 {
25 }
26
27 AArch64VectorPcsAttr *clone(ASTContext &C) const;
28 void printPretty(raw_ostream &OS,
29 const PrintingPolicy &Policy) const;
30 const char *getSpelling() const;
31
32
33 static bool classof(const Attr *A) { return A->getKind() == attr::AArch64VectorPcs; }
34};
35
36class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
37Expr * min;
38
39Expr * max;
40
41public:
42 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Loc = SourceRange()) {
43 auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0);
44 A->setImplicit(true);
45 return A;
46 }
47
48 AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
49 , Expr * Min
50 , Expr * Max
51 , unsigned SI
52 )
53 : InheritableAttr(attr::AMDGPUFlatWorkGroupSize, R, SI, false, false)
54 , min(Min)
55 , max(Max)
56 {
57 }
58
59 AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const;
60 void printPretty(raw_ostream &OS,
61 const PrintingPolicy &Policy) const;
62 const char *getSpelling() const;
63 Expr * getMin() const {
64 return min;
65 }
66
67 Expr * getMax() const {
68 return max;
69 }
70
71
72
73 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; }
74};
75
76class AMDGPUNumSGPRAttr : public InheritableAttr {
77unsigned numSGPR;
78
79public:
80 static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) {
81 auto *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0);
82 A->setImplicit(true);
83 return A;
84 }
85
86 AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx
87 , unsigned NumSGPR
88 , unsigned SI
89 )
90 : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, false, false)
91 , numSGPR(NumSGPR)
92 {
93 }
94
95 AMDGPUNumSGPRAttr *clone(ASTContext &C) const;
96 void printPretty(raw_ostream &OS,
97 const PrintingPolicy &Policy) const;
98 const char *getSpelling() const;
99 unsigned getNumSGPR() const {
100 return numSGPR;
101 }
102
103
104
105 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; }
106};
107
108class AMDGPUNumVGPRAttr : public InheritableAttr {
109unsigned numVGPR;
110
111public:
112 static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) {
113 auto *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0);
114 A->setImplicit(true);
115 return A;
116 }
117
118 AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx
119 , unsigned NumVGPR
120 , unsigned SI
121 )
122 : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, false, false)
123 , numVGPR(NumVGPR)
124 {
125 }
126
127 AMDGPUNumVGPRAttr *clone(ASTContext &C) const;
128 void printPretty(raw_ostream &OS,
129 const PrintingPolicy &Policy) const;
130 const char *getSpelling() const;
131 unsigned getNumVGPR() const {
132 return numVGPR;
133 }
134
135
136
137 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; }
138};
139
140class AMDGPUWavesPerEUAttr : public InheritableAttr {
141Expr * min;
142
143Expr * max;
144
145public:
146 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Loc = SourceRange()) {
147 auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0);
148 A->setImplicit(true);
149 return A;
150 }
151
152 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
153 , Expr * Min
154 , Expr * Max
155 , unsigned SI
156 )
157 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
158 , min(Min)
159 , max(Max)
160 {
161 }
162
163 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
164 , Expr * Min
165 , unsigned SI
166 )
167 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
168 , min(Min)
169 , max()
170 {
171 }
172
173 AMDGPUWavesPerEUAttr *clone(ASTContext &C) const;
174 void printPretty(raw_ostream &OS,
175 const PrintingPolicy &Policy) const;
176 const char *getSpelling() const;
177 Expr * getMin() const {
178 return min;
179 }
180
181 Expr * getMax() const {
182 return max;
183 }
184
185
186
187 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; }
188};
189
190class ARMInterruptAttr : public InheritableAttr {
191public:
192 enum InterruptType {
193 IRQ,
194 FIQ,
195 SWI,
196 ABORT,
197 UNDEF,
198 Generic
199 };
200private:
201 InterruptType interrupt;
202
203public:
204 static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
205 auto *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0);
206 A->setImplicit(true);
207 return A;
208 }
209
210 ARMInterruptAttr(SourceRange R, ASTContext &Ctx
211 , InterruptType Interrupt
212 , unsigned SI
213 )
214 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
215 , interrupt(Interrupt)
216 {
217 }
218
219 ARMInterruptAttr(SourceRange R, ASTContext &Ctx
220 , unsigned SI
221 )
222 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
223 , interrupt(InterruptType(0))
224 {
225 }
226
227 ARMInterruptAttr *clone(ASTContext &C) const;
228 void printPretty(raw_ostream &OS,
229 const PrintingPolicy &Policy) const;
230 const char *getSpelling() const;
231 InterruptType getInterrupt() const {
232 return interrupt;
233 }
234
235 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
236 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
237 .Case("IRQ", ARMInterruptAttr::IRQ)
238 .Case("FIQ", ARMInterruptAttr::FIQ)
239 .Case("SWI", ARMInterruptAttr::SWI)
240 .Case("ABORT", ARMInterruptAttr::ABORT)
241 .Case("UNDEF", ARMInterruptAttr::UNDEF)
242 .Case("", ARMInterruptAttr::Generic)
243 .Default(Optional<InterruptType>());
244 if (R) {
245 Out = *R;
246 return true;
247 }
248 return false;
249 }
250
251 static const char *ConvertInterruptTypeToStr(InterruptType Val) {
252 switch(Val) {
253 case ARMInterruptAttr::IRQ: return "IRQ";
254 case ARMInterruptAttr::FIQ: return "FIQ";
255 case ARMInterruptAttr::SWI: return "SWI";
256 case ARMInterruptAttr::ABORT: return "ABORT";
257 case ARMInterruptAttr::UNDEF: return "UNDEF";
258 case ARMInterruptAttr::Generic: return "";
259 }
260 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 260)
;
261 }
262
263
264 static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; }
265};
266
267class AVRInterruptAttr : public InheritableAttr {
268public:
269 static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
270 auto *A = new (Ctx) AVRInterruptAttr(Loc, Ctx, 0);
271 A->setImplicit(true);
272 return A;
273 }
274
275 AVRInterruptAttr(SourceRange R, ASTContext &Ctx
276 , unsigned SI
277 )
278 : InheritableAttr(attr::AVRInterrupt, R, SI, false, false)
279 {
280 }
281
282 AVRInterruptAttr *clone(ASTContext &C) const;
283 void printPretty(raw_ostream &OS,
284 const PrintingPolicy &Policy) const;
285 const char *getSpelling() const;
286
287
288 static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; }
289};
290
291class AVRSignalAttr : public InheritableAttr {
292public:
293 static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
294 auto *A = new (Ctx) AVRSignalAttr(Loc, Ctx, 0);
295 A->setImplicit(true);
296 return A;
297 }
298
299 AVRSignalAttr(SourceRange R, ASTContext &Ctx
300 , unsigned SI
301 )
302 : InheritableAttr(attr::AVRSignal, R, SI, false, false)
303 {
304 }
305
306 AVRSignalAttr *clone(ASTContext &C) const;
307 void printPretty(raw_ostream &OS,
308 const PrintingPolicy &Policy) const;
309 const char *getSpelling() const;
310
311
312 static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; }
313};
314
315class AbiTagAttr : public Attr {
316 unsigned tags_Size;
317 StringRef *tags_;
318
319public:
320 static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Loc = SourceRange()) {
321 auto *A = new (Ctx) AbiTagAttr(Loc, Ctx, Tags, TagsSize, 0);
322 A->setImplicit(true);
323 return A;
324 }
325
326 AbiTagAttr(SourceRange R, ASTContext &Ctx
327 , StringRef *Tags, unsigned TagsSize
328 , unsigned SI
329 )
330 : Attr(attr::AbiTag, R, SI, false)
331 , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size])
332 {
333 for (size_t I = 0, E = tags_Size; I != E;
334 ++I) {
335 StringRef Ref = Tags[I];
336 if (!Ref.empty()) {
337 char *Mem = new (Ctx, 1) char[Ref.size()];
338 std::memcpy(Mem, Ref.data(), Ref.size());
339 tags_[I] = StringRef(Mem, Ref.size());
340 }
341 }
342 }
343
344 AbiTagAttr(SourceRange R, ASTContext &Ctx
345 , unsigned SI
346 )
347 : Attr(attr::AbiTag, R, SI, false)
348 , tags_Size(0), tags_(nullptr)
349 {
350 }
351
352 AbiTagAttr *clone(ASTContext &C) const;
353 void printPretty(raw_ostream &OS,
354 const PrintingPolicy &Policy) const;
355 const char *getSpelling() const;
356 typedef StringRef* tags_iterator;
357 tags_iterator tags_begin() const { return tags_; }
358 tags_iterator tags_end() const { return tags_ + tags_Size; }
359 unsigned tags_size() const { return tags_Size; }
360 llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); }
361
362
363
364
365 static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; }
366};
367
368class AcquireCapabilityAttr : public InheritableAttr {
369 unsigned args_Size;
370 Expr * *args_;
371
372public:
373 enum Spelling {
374 GNU_acquire_capability = 0,
375 CXX11_clang_acquire_capability = 1,
376 GNU_acquire_shared_capability = 2,
377 CXX11_clang_acquire_shared_capability = 3,
378 GNU_exclusive_lock_function = 4,
379 GNU_shared_lock_function = 5
380 };
381
382 static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
383 auto *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
384 A->setImplicit(true);
385 return A;
386 }
387
388 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
389 , Expr * *Args, unsigned ArgsSize
390 , unsigned SI
391 )
392 : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
393 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
394 {
395 std::copy(Args, Args + args_Size, args_);
396 }
397
398 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
399 , unsigned SI
400 )
401 : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
402 , args_Size(0), args_(nullptr)
403 {
404 }
405
406 AcquireCapabilityAttr *clone(ASTContext &C) const;
407 void printPretty(raw_ostream &OS,
408 const PrintingPolicy &Policy) const;
409 const char *getSpelling() const;
410 Spelling getSemanticSpelling() const {
411 switch (SpellingListIndex) {
412 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 412)
;
413 case 0: return GNU_acquire_capability;
414 case 1: return CXX11_clang_acquire_capability;
415 case 2: return GNU_acquire_shared_capability;
416 case 3: return CXX11_clang_acquire_shared_capability;
417 case 4: return GNU_exclusive_lock_function;
418 case 5: return GNU_shared_lock_function;
419 }
420 }
421 bool isShared() const { return SpellingListIndex == 2 ||
422 SpellingListIndex == 3 ||
423 SpellingListIndex == 5; }
424 typedef Expr ** args_iterator;
425 args_iterator args_begin() const { return args_; }
426 args_iterator args_end() const { return args_ + args_Size; }
427 unsigned args_size() const { return args_Size; }
428 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
429
430
431
432
433 static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; }
434};
435
436class AcquiredAfterAttr : public InheritableAttr {
437 unsigned args_Size;
438 Expr * *args_;
439
440public:
441 static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
442 auto *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0);
443 A->setImplicit(true);
444 return A;
445 }
446
447 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
448 , Expr * *Args, unsigned ArgsSize
449 , unsigned SI
450 )
451 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
452 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
453 {
454 std::copy(Args, Args + args_Size, args_);
455 }
456
457 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
458 , unsigned SI
459 )
460 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
461 , args_Size(0), args_(nullptr)
462 {
463 }
464
465 AcquiredAfterAttr *clone(ASTContext &C) const;
466 void printPretty(raw_ostream &OS,
467 const PrintingPolicy &Policy) const;
468 const char *getSpelling() const;
469 typedef Expr ** args_iterator;
470 args_iterator args_begin() const { return args_; }
471 args_iterator args_end() const { return args_ + args_Size; }
472 unsigned args_size() const { return args_Size; }
473 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
474
475
476
477
478 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; }
479};
480
481class AcquiredBeforeAttr : public InheritableAttr {
482 unsigned args_Size;
483 Expr * *args_;
484
485public:
486 static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
487 auto *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0);
488 A->setImplicit(true);
489 return A;
490 }
491
492 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
493 , Expr * *Args, unsigned ArgsSize
494 , unsigned SI
495 )
496 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
497 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
498 {
499 std::copy(Args, Args + args_Size, args_);
500 }
501
502 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
503 , unsigned SI
504 )
505 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
506 , args_Size(0), args_(nullptr)
507 {
508 }
509
510 AcquiredBeforeAttr *clone(ASTContext &C) const;
511 void printPretty(raw_ostream &OS,
512 const PrintingPolicy &Policy) const;
513 const char *getSpelling() const;
514 typedef Expr ** args_iterator;
515 args_iterator args_begin() const { return args_; }
516 args_iterator args_end() const { return args_ + args_Size; }
517 unsigned args_size() const { return args_Size; }
518 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
519
520
521
522
523 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; }
524};
525
526class AddressSpaceAttr : public TypeAttr {
527int addressSpace;
528
529public:
530 static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, SourceRange Loc = SourceRange()) {
531 auto *A = new (Ctx) AddressSpaceAttr(Loc, Ctx, AddressSpace, 0);
532 A->setImplicit(true);
533 return A;
534 }
535
536 AddressSpaceAttr(SourceRange R, ASTContext &Ctx
537 , int AddressSpace
538 , unsigned SI
539 )
540 : TypeAttr(attr::AddressSpace, R, SI, false)
541 , addressSpace(AddressSpace)
542 {
543 }
544
545 AddressSpaceAttr *clone(ASTContext &C) const;
546 void printPretty(raw_ostream &OS,
547 const PrintingPolicy &Policy) const;
548 const char *getSpelling() const;
549 int getAddressSpace() const {
550 return addressSpace;
551 }
552
553
554
555 static bool classof(const Attr *A) { return A->getKind() == attr::AddressSpace; }
556};
557
558class AliasAttr : public Attr {
559unsigned aliaseeLength;
560char *aliasee;
561
562public:
563 static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
564 auto *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0);
565 A->setImplicit(true);
566 return A;
567 }
568
569 AliasAttr(SourceRange R, ASTContext &Ctx
570 , llvm::StringRef Aliasee
571 , unsigned SI
572 )
573 : Attr(attr::Alias, R, SI, false)
574 , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
575 {
576 if (!Aliasee.empty())
577 std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
578 }
579
580 AliasAttr *clone(ASTContext &C) const;
581 void printPretty(raw_ostream &OS,
582 const PrintingPolicy &Policy) const;
583 const char *getSpelling() const;
584 llvm::StringRef getAliasee() const {
585 return llvm::StringRef(aliasee, aliaseeLength);
586 }
587 unsigned getAliaseeLength() const {
588 return aliaseeLength;
589 }
590 void setAliasee(ASTContext &C, llvm::StringRef S) {
591 aliaseeLength = S.size();
592 this->aliasee = new (C, 1) char [aliaseeLength];
593 if (!S.empty())
594 std::memcpy(this->aliasee, S.data(), aliaseeLength);
595 }
596
597
598
599 static bool classof(const Attr *A) { return A->getKind() == attr::Alias; }
600};
601
602class AlignMac68kAttr : public InheritableAttr {
603public:
604 static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
605 auto *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0);
606 A->setImplicit(true);
607 return A;
608 }
609
610 AlignMac68kAttr(SourceRange R, ASTContext &Ctx
611 , unsigned SI
612 )
613 : InheritableAttr(attr::AlignMac68k, R, SI, false, false)
614 {
615 }
616
617 AlignMac68kAttr *clone(ASTContext &C) const;
618 void printPretty(raw_ostream &OS,
619 const PrintingPolicy &Policy) const;
620 const char *getSpelling() const;
621
622
623 static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; }
624};
625
626class AlignValueAttr : public Attr {
627Expr * alignment;
628
629public:
630 static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) {
631 auto *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0);
632 A->setImplicit(true);
633 return A;
634 }
635
636 AlignValueAttr(SourceRange R, ASTContext &Ctx
637 , Expr * Alignment
638 , unsigned SI
639 )
640 : Attr(attr::AlignValue, R, SI, false)
641 , alignment(Alignment)
642 {
643 }
644
645 AlignValueAttr *clone(ASTContext &C) const;
646 void printPretty(raw_ostream &OS,
647 const PrintingPolicy &Policy) const;
648 const char *getSpelling() const;
649 Expr * getAlignment() const {
650 return alignment;
651 }
652
653
654
655 static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; }
656};
657
658class AlignedAttr : public InheritableAttr {
659bool isalignmentExpr;
660union {
661Expr *alignmentExpr;
662TypeSourceInfo *alignmentType;
663};
664
665public:
666 enum Spelling {
667 GNU_aligned = 0,
668 CXX11_gnu_aligned = 1,
669 Declspec_align = 2,
670 Keyword_alignas = 3,
671 Keyword_Alignas = 4
672 };
673
674 static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) {
675 auto *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S);
676 A->setImplicit(true);
677 return A;
678 }
679
680 AlignedAttr(SourceRange R, ASTContext &Ctx
681 , bool IsAlignmentExpr, void *Alignment
682 , unsigned SI
683 )
684 : InheritableAttr(attr::Aligned, R, SI, false, false)
685 , isalignmentExpr(IsAlignmentExpr)
686 {
687 if (isalignmentExpr)
688 alignmentExpr = reinterpret_cast<Expr *>(Alignment);
689 else
690 alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment);
691 }
692
693 AlignedAttr(SourceRange R, ASTContext &Ctx
694 , unsigned SI
695 )
696 : InheritableAttr(attr::Aligned, R, SI, false, false)
697 , isalignmentExpr(false)
698 {
699 }
700
701 AlignedAttr *clone(ASTContext &C) const;
702 void printPretty(raw_ostream &OS,
703 const PrintingPolicy &Policy) const;
704 const char *getSpelling() const;
705 Spelling getSemanticSpelling() const {
706 switch (SpellingListIndex) {
707 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 707)
;
708 case 0: return GNU_aligned;
709 case 1: return CXX11_gnu_aligned;
710 case 2: return Declspec_align;
711 case 3: return Keyword_alignas;
712 case 4: return Keyword_Alignas;
713 }
714 }
715 bool isGNU() const { return SpellingListIndex == 0 ||
716 SpellingListIndex == 1; }
717 bool isC11() const { return SpellingListIndex == 4; }
718 bool isAlignas() const { return SpellingListIndex == 3 ||
719 SpellingListIndex == 4; }
720 bool isDeclspec() const { return SpellingListIndex == 2; }
721 bool isAlignmentDependent() const;
722 unsigned getAlignment(ASTContext &Ctx) const;
723 bool isAlignmentExpr() const {
724 return isalignmentExpr;
725 }
726 Expr *getAlignmentExpr() const {
727 assert(isalignmentExpr)((isalignmentExpr) ? static_cast<void> (0) : __assert_fail
("isalignmentExpr", "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 727, __PRETTY_FUNCTION__))
;
728 return alignmentExpr;
729 }
730 TypeSourceInfo *getAlignmentType() const {
731 assert(!isalignmentExpr)((!isalignmentExpr) ? static_cast<void> (0) : __assert_fail
("!isalignmentExpr", "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 731, __PRETTY_FUNCTION__))
;
732 return alignmentType;
733 }
734
735
736
737 static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; }
738};
739
740class AllocAlignAttr : public InheritableAttr {
741ParamIdx paramIndex;
742
743public:
744 static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Loc = SourceRange()) {
745 auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0);
746 A->setImplicit(true);
747 return A;
748 }
749
750 AllocAlignAttr(SourceRange R, ASTContext &Ctx
751 , ParamIdx ParamIndex
752 , unsigned SI
753 )
754 : InheritableAttr(attr::AllocAlign, R, SI, false, false)
755 , paramIndex(ParamIndex)
756 {
757 }
758
759 AllocAlignAttr *clone(ASTContext &C) const;
760 void printPretty(raw_ostream &OS,
761 const PrintingPolicy &Policy) const;
762 const char *getSpelling() const;
763 ParamIdx getParamIndex() const {
764 return paramIndex;
765 }
766
767
768
769 static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; }
770};
771
772class AllocSizeAttr : public InheritableAttr {
773ParamIdx elemSizeParam;
774
775ParamIdx numElemsParam;
776
777public:
778 static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Loc = SourceRange()) {
779 auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0);
780 A->setImplicit(true);
781 return A;
782 }
783
784 AllocSizeAttr(SourceRange R, ASTContext &Ctx
785 , ParamIdx ElemSizeParam
786 , ParamIdx NumElemsParam
787 , unsigned SI
788 )
789 : InheritableAttr(attr::AllocSize, R, SI, false, false)
790 , elemSizeParam(ElemSizeParam)
791 , numElemsParam(NumElemsParam)
792 {
793 }
794
795 AllocSizeAttr(SourceRange R, ASTContext &Ctx
796 , ParamIdx ElemSizeParam
797 , unsigned SI
798 )
799 : InheritableAttr(attr::AllocSize, R, SI, false, false)
800 , elemSizeParam(ElemSizeParam)
801 , numElemsParam()
802 {
803 }
804
805 AllocSizeAttr *clone(ASTContext &C) const;
806 void printPretty(raw_ostream &OS,
807 const PrintingPolicy &Policy) const;
808 const char *getSpelling() const;
809 ParamIdx getElemSizeParam() const {
810 return elemSizeParam;
811 }
812
813 ParamIdx getNumElemsParam() const {
814 return numElemsParam;
815 }
816
817
818
819 static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; }
820};
821
822class AlwaysDestroyAttr : public InheritableAttr {
823public:
824 static AlwaysDestroyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
825 auto *A = new (Ctx) AlwaysDestroyAttr(Loc, Ctx, 0);
826 A->setImplicit(true);
827 return A;
828 }
829
830 AlwaysDestroyAttr(SourceRange R, ASTContext &Ctx
831 , unsigned SI
832 )
833 : InheritableAttr(attr::AlwaysDestroy, R, SI, false, false)
834 {
835 }
836
837 AlwaysDestroyAttr *clone(ASTContext &C) const;
838 void printPretty(raw_ostream &OS,
839 const PrintingPolicy &Policy) const;
840 const char *getSpelling() const;
841
842
843 static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysDestroy; }
844};
845
846class AlwaysInlineAttr : public InheritableAttr {
847public:
848 enum Spelling {
849 GNU_always_inline = 0,
850 CXX11_gnu_always_inline = 1,
851 Keyword_forceinline = 2
852 };
853
854 static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
855 auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S);
856 A->setImplicit(true);
857 return A;
858 }
859
860 AlwaysInlineAttr(SourceRange R, ASTContext &Ctx
861 , unsigned SI
862 )
863 : InheritableAttr(attr::AlwaysInline, R, SI, false, false)
864 {
865 }
866
867 AlwaysInlineAttr *clone(ASTContext &C) const;
868 void printPretty(raw_ostream &OS,
869 const PrintingPolicy &Policy) const;
870 const char *getSpelling() const;
871 Spelling getSemanticSpelling() const {
872 switch (SpellingListIndex) {
873 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 873)
;
874 case 0: return GNU_always_inline;
875 case 1: return CXX11_gnu_always_inline;
876 case 2: return Keyword_forceinline;
877 }
878 }
879
880
881 static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; }
882};
883
884class AnalyzerNoReturnAttr : public InheritableAttr {
885public:
886 static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
887 auto *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0);
888 A->setImplicit(true);
889 return A;
890 }
891
892 AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx
893 , unsigned SI
894 )
895 : InheritableAttr(attr::AnalyzerNoReturn, R, SI, false, false)
896 {
897 }
898
899 AnalyzerNoReturnAttr *clone(ASTContext &C) const;
900 void printPretty(raw_ostream &OS,
901 const PrintingPolicy &Policy) const;
902 const char *getSpelling() const;
903
904
905 static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; }
906};
907
908class AnnotateAttr : public InheritableParamAttr {
909unsigned annotationLength;
910char *annotation;
911
912public:
913 static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) {
914 auto *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0);
915 A->setImplicit(true);
916 return A;
917 }
918
919 AnnotateAttr(SourceRange R, ASTContext &Ctx
920 , llvm::StringRef Annotation
921 , unsigned SI
922 )
923 : InheritableParamAttr(attr::Annotate, R, SI, false, false)
924 , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength])
925 {
926 if (!Annotation.empty())
927 std::memcpy(annotation, Annotation.data(), annotationLength);
928 }
929
930 AnnotateAttr *clone(ASTContext &C) const;
931 void printPretty(raw_ostream &OS,
932 const PrintingPolicy &Policy) const;
933 const char *getSpelling() const;
934 llvm::StringRef getAnnotation() const {
935 return llvm::StringRef(annotation, annotationLength);
936 }
937 unsigned getAnnotationLength() const {
938 return annotationLength;
939 }
940 void setAnnotation(ASTContext &C, llvm::StringRef S) {
941 annotationLength = S.size();
942 this->annotation = new (C, 1) char [annotationLength];
943 if (!S.empty())
944 std::memcpy(this->annotation, S.data(), annotationLength);
945 }
946
947
948
949 static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; }
950};
951
952class AnyX86InterruptAttr : public InheritableAttr {
953public:
954 static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
955 auto *A = new (Ctx) AnyX86InterruptAttr(Loc, Ctx, 0);
956 A->setImplicit(true);
957 return A;
958 }
959
960 AnyX86InterruptAttr(SourceRange R, ASTContext &Ctx
961 , unsigned SI
962 )
963 : InheritableAttr(attr::AnyX86Interrupt, R, SI, false, false)
964 {
965 }
966
967 AnyX86InterruptAttr *clone(ASTContext &C) const;
968 void printPretty(raw_ostream &OS,
969 const PrintingPolicy &Policy) const;
970 const char *getSpelling() const;
971
972
973 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; }
974};
975
976class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
977public:
978 static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
979 auto *A = new (Ctx) AnyX86NoCallerSavedRegistersAttr(Loc, Ctx, 0);
980 A->setImplicit(true);
981 return A;
982 }
983
984 AnyX86NoCallerSavedRegistersAttr(SourceRange R, ASTContext &Ctx
985 , unsigned SI
986 )
987 : InheritableAttr(attr::AnyX86NoCallerSavedRegisters, R, SI, false, false)
988 {
989 }
990
991 AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const;
992 void printPretty(raw_ostream &OS,
993 const PrintingPolicy &Policy) const;
994 const char *getSpelling() const;
995
996
997 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; }
998};
999
1000class AnyX86NoCfCheckAttr : public InheritableAttr {
1001public:
1002 static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1003 auto *A = new (Ctx) AnyX86NoCfCheckAttr(Loc, Ctx, 0);
1004 A->setImplicit(true);
1005 return A;
1006 }
1007
1008 AnyX86NoCfCheckAttr(SourceRange R, ASTContext &Ctx
1009 , unsigned SI
1010 )
1011 : InheritableAttr(attr::AnyX86NoCfCheck, R, SI, false, false)
1012 {
1013 }
1014
1015 AnyX86NoCfCheckAttr *clone(ASTContext &C) const;
1016 void printPretty(raw_ostream &OS,
1017 const PrintingPolicy &Policy) const;
1018 const char *getSpelling() const;
1019
1020
1021 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCfCheck; }
1022};
1023
1024class ArcWeakrefUnavailableAttr : public InheritableAttr {
1025public:
1026 static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1027 auto *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0);
1028 A->setImplicit(true);
1029 return A;
1030 }
1031
1032 ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx
1033 , unsigned SI
1034 )
1035 : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, false, false)
1036 {
1037 }
1038
1039 ArcWeakrefUnavailableAttr *clone(ASTContext &C) const;
1040 void printPretty(raw_ostream &OS,
1041 const PrintingPolicy &Policy) const;
1042 const char *getSpelling() const;
1043
1044
1045 static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; }
1046};
1047
1048class ArgumentWithTypeTagAttr : public InheritableAttr {
1049IdentifierInfo * argumentKind;
1050
1051ParamIdx argumentIdx;
1052
1053ParamIdx typeTagIdx;
1054
1055bool isPointer;
1056
1057public:
1058 enum Spelling {
1059 GNU_argument_with_type_tag = 0,
1060 CXX11_clang_argument_with_type_tag = 1,
1061 C2x_clang_argument_with_type_tag = 2,
1062 GNU_pointer_with_type_tag = 3,
1063 CXX11_clang_pointer_with_type_tag = 4,
1064 C2x_clang_pointer_with_type_tag = 5
1065 };
1066
1067 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) {
1068 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S);
1069 A->setImplicit(true);
1070 return A;
1071 }
1072
1073 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Loc = SourceRange()) {
1074 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, S);
1075 A->setImplicit(true);
1076 return A;
1077 }
1078
1079 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
1080 , IdentifierInfo * ArgumentKind
1081 , ParamIdx ArgumentIdx
1082 , ParamIdx TypeTagIdx
1083 , bool IsPointer
1084 , unsigned SI
1085 )
1086 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
1087 , argumentKind(ArgumentKind)
1088 , argumentIdx(ArgumentIdx)
1089 , typeTagIdx(TypeTagIdx)
1090 , isPointer(IsPointer)
1091 {
1092 }
1093
1094 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
1095 , IdentifierInfo * ArgumentKind
1096 , ParamIdx ArgumentIdx
1097 , ParamIdx TypeTagIdx
1098 , unsigned SI
1099 )
1100 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
1101 , argumentKind(ArgumentKind)
1102 , argumentIdx(ArgumentIdx)
1103 , typeTagIdx(TypeTagIdx)
1104 , isPointer()
1105 {
1106 }
1107
1108 ArgumentWithTypeTagAttr *clone(ASTContext &C) const;
1109 void printPretty(raw_ostream &OS,
1110 const PrintingPolicy &Policy) const;
1111 const char *getSpelling() const;
1112 Spelling getSemanticSpelling() const {
1113 switch (SpellingListIndex) {
1114 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1114)
;
1115 case 0: return GNU_argument_with_type_tag;
1116 case 1: return CXX11_clang_argument_with_type_tag;
1117 case 2: return C2x_clang_argument_with_type_tag;
1118 case 3: return GNU_pointer_with_type_tag;
1119 case 4: return CXX11_clang_pointer_with_type_tag;
1120 case 5: return C2x_clang_pointer_with_type_tag;
1121 }
1122 }
1123 IdentifierInfo * getArgumentKind() const {
1124 return argumentKind;
1125 }
1126
1127 ParamIdx getArgumentIdx() const {
1128 return argumentIdx;
1129 }
1130
1131 ParamIdx getTypeTagIdx() const {
1132 return typeTagIdx;
1133 }
1134
1135 bool getIsPointer() const {
1136 return isPointer;
1137 }
1138
1139
1140
1141 static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
1142};
1143
1144class ArtificialAttr : public InheritableAttr {
1145public:
1146 static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1147 auto *A = new (Ctx) ArtificialAttr(Loc, Ctx, 0);
1148 A->setImplicit(true);
1149 return A;
1150 }
1151
1152 ArtificialAttr(SourceRange R, ASTContext &Ctx
1153 , unsigned SI
1154 )
1155 : InheritableAttr(attr::Artificial, R, SI, false, false)
1156 {
1157 }
1158
1159 ArtificialAttr *clone(ASTContext &C) const;
1160 void printPretty(raw_ostream &OS,
1161 const PrintingPolicy &Policy) const;
1162 const char *getSpelling() const;
1163
1164
1165 static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; }
1166};
1167
1168class AsmLabelAttr : public InheritableAttr {
1169unsigned labelLength;
1170char *label;
1171
1172public:
1173 static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) {
1174 auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0);
1175 A->setImplicit(true);
1176 return A;
1177 }
1178
1179 AsmLabelAttr(SourceRange R, ASTContext &Ctx
1180 , llvm::StringRef Label
1181 , unsigned SI
1182 )
1183 : InheritableAttr(attr::AsmLabel, R, SI, false, false)
1184 , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
1185 {
1186 if (!Label.empty())
1187 std::memcpy(label, Label.data(), labelLength);
1188 }
1189
1190 AsmLabelAttr *clone(ASTContext &C) const;
1191 void printPretty(raw_ostream &OS,
1192 const PrintingPolicy &Policy) const;
1193 const char *getSpelling() const;
1194 llvm::StringRef getLabel() const {
1195 return llvm::StringRef(label, labelLength);
1196 }
1197 unsigned getLabelLength() const {
1198 return labelLength;
1199 }
1200 void setLabel(ASTContext &C, llvm::StringRef S) {
1201 labelLength = S.size();
1202 this->label = new (C, 1) char [labelLength];
1203 if (!S.empty())
1204 std::memcpy(this->label, S.data(), labelLength);
1205 }
1206
1207
1208
1209 static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; }
1210};
1211
1212class AssertCapabilityAttr : public InheritableAttr {
1213 unsigned args_Size;
1214 Expr * *args_;
1215
1216public:
1217 enum Spelling {
1218 GNU_assert_capability = 0,
1219 CXX11_clang_assert_capability = 1,
1220 GNU_assert_shared_capability = 2,
1221 CXX11_clang_assert_shared_capability = 3
1222 };
1223
1224 static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
1225 auto *A = new (Ctx) AssertCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
1226 A->setImplicit(true);
1227 return A;
1228 }
1229
1230 AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
1231 , Expr * *Args, unsigned ArgsSize
1232 , unsigned SI
1233 )
1234 : InheritableAttr(attr::AssertCapability, R, SI, true, true)
1235 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1236 {
1237 std::copy(Args, Args + args_Size, args_);
1238 }
1239
1240 AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
1241 , unsigned SI
1242 )
1243 : InheritableAttr(attr::AssertCapability, R, SI, true, true)
1244 , args_Size(0), args_(nullptr)
1245 {
1246 }
1247
1248 AssertCapabilityAttr *clone(ASTContext &C) const;
1249 void printPretty(raw_ostream &OS,
1250 const PrintingPolicy &Policy) const;
1251 const char *getSpelling() const;
1252 Spelling getSemanticSpelling() const {
1253 switch (SpellingListIndex) {
1254 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1254)
;
1255 case 0: return GNU_assert_capability;
1256 case 1: return CXX11_clang_assert_capability;
1257 case 2: return GNU_assert_shared_capability;
1258 case 3: return CXX11_clang_assert_shared_capability;
1259 }
1260 }
1261 bool isShared() const { return SpellingListIndex == 2 ||
1262 SpellingListIndex == 3; }
1263 typedef Expr ** args_iterator;
1264 args_iterator args_begin() const { return args_; }
1265 args_iterator args_end() const { return args_ + args_Size; }
1266 unsigned args_size() const { return args_Size; }
1267 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1268
1269
1270
1271
1272 static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; }
1273};
1274
1275class AssertExclusiveLockAttr : public InheritableAttr {
1276 unsigned args_Size;
1277 Expr * *args_;
1278
1279public:
1280 static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
1281 auto *A = new (Ctx) AssertExclusiveLockAttr(Loc, Ctx, Args, ArgsSize, 0);
1282 A->setImplicit(true);
1283 return A;
1284 }
1285
1286 AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
1287 , Expr * *Args, unsigned ArgsSize
1288 , unsigned SI
1289 )
1290 : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true)
1291 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1292 {
1293 std::copy(Args, Args + args_Size, args_);
1294 }
1295
1296 AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
1297 , unsigned SI
1298 )
1299 : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true)
1300 , args_Size(0), args_(nullptr)
1301 {
1302 }
1303
1304 AssertExclusiveLockAttr *clone(ASTContext &C) const;
1305 void printPretty(raw_ostream &OS,
1306 const PrintingPolicy &Policy) const;
1307 const char *getSpelling() const;
1308 typedef Expr ** args_iterator;
1309 args_iterator args_begin() const { return args_; }
1310 args_iterator args_end() const { return args_ + args_Size; }
1311 unsigned args_size() const { return args_Size; }
1312 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1313
1314
1315
1316
1317 static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; }
1318};
1319
1320class AssertSharedLockAttr : public InheritableAttr {
1321 unsigned args_Size;
1322 Expr * *args_;
1323
1324public:
1325 static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
1326 auto *A = new (Ctx) AssertSharedLockAttr(Loc, Ctx, Args, ArgsSize, 0);
1327 A->setImplicit(true);
1328 return A;
1329 }
1330
1331 AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
1332 , Expr * *Args, unsigned ArgsSize
1333 , unsigned SI
1334 )
1335 : InheritableAttr(attr::AssertSharedLock, R, SI, true, true)
1336 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1337 {
1338 std::copy(Args, Args + args_Size, args_);
1339 }
1340
1341 AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
1342 , unsigned SI
1343 )
1344 : InheritableAttr(attr::AssertSharedLock, R, SI, true, true)
1345 , args_Size(0), args_(nullptr)
1346 {
1347 }
1348
1349 AssertSharedLockAttr *clone(ASTContext &C) const;
1350 void printPretty(raw_ostream &OS,
1351 const PrintingPolicy &Policy) const;
1352 const char *getSpelling() const;
1353 typedef Expr ** args_iterator;
1354 args_iterator args_begin() const { return args_; }
1355 args_iterator args_end() const { return args_ + args_Size; }
1356 unsigned args_size() const { return args_Size; }
1357 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1358
1359
1360
1361
1362 static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; }
1363};
1364
1365class AssumeAlignedAttr : public InheritableAttr {
1366Expr * alignment;
1367
1368Expr * offset;
1369
1370public:
1371 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Loc = SourceRange()) {
1372 auto *A = new (Ctx) AssumeAlignedAttr(Loc, Ctx, Alignment, Offset, 0);
1373 A->setImplicit(true);
1374 return A;
1375 }
1376
1377 AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
1378 , Expr * Alignment
1379 , Expr * Offset
1380 , unsigned SI
1381 )
1382 : InheritableAttr(attr::AssumeAligned, R, SI, false, false)
1383 , alignment(Alignment)
1384 , offset(Offset)
1385 {
1386 }
1387
1388 AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
1389 , Expr * Alignment
1390 , unsigned SI
1391 )
1392 : InheritableAttr(attr::AssumeAligned, R, SI, false, false)
1393 , alignment(Alignment)
1394 , offset()
1395 {
1396 }
1397
1398 AssumeAlignedAttr *clone(ASTContext &C) const;
1399 void printPretty(raw_ostream &OS,
1400 const PrintingPolicy &Policy) const;
1401 const char *getSpelling() const;
1402 Expr * getAlignment() const {
1403 return alignment;
1404 }
1405
1406 Expr * getOffset() const {
1407 return offset;
1408 }
1409
1410
1411
1412 static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; }
1413};
1414
1415class AvailabilityAttr : public InheritableAttr {
1416IdentifierInfo * platform;
1417
1418VersionTuple introduced;
1419
1420
1421VersionTuple deprecated;
1422
1423
1424VersionTuple obsoleted;
1425
1426
1427bool unavailable;
1428
1429unsigned messageLength;
1430char *message;
1431
1432bool strict;
1433
1434unsigned replacementLength;
1435char *replacement;
1436
1437int priority;
1438
1439public:
1440 static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, SourceRange Loc = SourceRange()) {
1441 auto *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, Strict, Replacement, Priority, 0);
1442 A->setImplicit(true);
1443 return A;
1444 }
1445
1446 AvailabilityAttr(SourceRange R, ASTContext &Ctx
1447 , IdentifierInfo * Platform
1448 , VersionTuple Introduced
1449 , VersionTuple Deprecated
1450 , VersionTuple Obsoleted
1451 , bool Unavailable
1452 , llvm::StringRef Message
1453 , bool Strict
1454 , llvm::StringRef Replacement
1455 , int Priority
1456 , unsigned SI
1457 )
1458 : InheritableAttr(attr::Availability, R, SI, false, true)
1459 , platform(Platform)
1460 , introduced(Introduced)
1461 , deprecated(Deprecated)
1462 , obsoleted(Obsoleted)
1463 , unavailable(Unavailable)
1464 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
1465 , strict(Strict)
1466 , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
1467 , priority(Priority)
1468 {
1469 if (!Message.empty())
1470 std::memcpy(message, Message.data(), messageLength);
1471 if (!Replacement.empty())
1472 std::memcpy(replacement, Replacement.data(), replacementLength);
1473 }
1474
1475 AvailabilityAttr *clone(ASTContext &C) const;
1476 void printPretty(raw_ostream &OS,
1477 const PrintingPolicy &Policy) const;
1478 const char *getSpelling() const;
1479 IdentifierInfo * getPlatform() const {
1480 return platform;
1481 }
1482
1483 VersionTuple getIntroduced() const {
1484 return introduced;
1485 }
1486 void setIntroduced(ASTContext &C, VersionTuple V) {
1487 introduced = V;
1488 }
1489
1490 VersionTuple getDeprecated() const {
1491 return deprecated;
1492 }
1493 void setDeprecated(ASTContext &C, VersionTuple V) {
1494 deprecated = V;
1495 }
1496
1497 VersionTuple getObsoleted() const {
1498 return obsoleted;
1499 }
1500 void setObsoleted(ASTContext &C, VersionTuple V) {
1501 obsoleted = V;
1502 }
1503
1504 bool getUnavailable() const {
1505 return unavailable;
1506 }
1507
1508 llvm::StringRef getMessage() const {
1509 return llvm::StringRef(message, messageLength);
1510 }
1511 unsigned getMessageLength() const {
1512 return messageLength;
1513 }
1514 void setMessage(ASTContext &C, llvm::StringRef S) {
1515 messageLength = S.size();
1516 this->message = new (C, 1) char [messageLength];
1517 if (!S.empty())
1518 std::memcpy(this->message, S.data(), messageLength);
1519 }
1520
1521 bool getStrict() const {
1522 return strict;
1523 }
1524
1525 llvm::StringRef getReplacement() const {
1526 return llvm::StringRef(replacement, replacementLength);
1527 }
1528 unsigned getReplacementLength() const {
1529 return replacementLength;
1530 }
1531 void setReplacement(ASTContext &C, llvm::StringRef S) {
1532 replacementLength = S.size();
1533 this->replacement = new (C, 1) char [replacementLength];
1534 if (!S.empty())
1535 std::memcpy(this->replacement, S.data(), replacementLength);
1536 }
1537
1538 int getPriority() const {
1539 return priority;
1540 }
1541
1542static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
1543 return llvm::StringSwitch<llvm::StringRef>(Platform)
1544 .Case("android", "Android")
1545 .Case("ios", "iOS")
1546 .Case("macos", "macOS")
1547 .Case("tvos", "tvOS")
1548 .Case("watchos", "watchOS")
1549 .Case("ios_app_extension", "iOS (App Extension)")
1550 .Case("macos_app_extension", "macOS (App Extension)")
1551 .Case("tvos_app_extension", "tvOS (App Extension)")
1552 .Case("watchos_app_extension", "watchOS (App Extension)")
1553 .Case("swift", "Swift")
1554 .Default(llvm::StringRef());
1555}
1556static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) {
1557 return llvm::StringSwitch<llvm::StringRef>(Platform)
1558 .Case("ios", "iOS")
1559 .Case("macos", "macOS")
1560 .Case("tvos", "tvOS")
1561 .Case("watchos", "watchOS")
1562 .Case("ios_app_extension", "iOSApplicationExtension")
1563 .Case("macos_app_extension", "macOSApplicationExtension")
1564 .Case("tvos_app_extension", "tvOSApplicationExtension")
1565 .Case("watchos_app_extension", "watchOSApplicationExtension")
1566 .Default(Platform);
1567}
1568static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) {
1569 return llvm::StringSwitch<llvm::StringRef>(Platform)
1570 .Case("iOS", "ios")
1571 .Case("macOS", "macos")
1572 .Case("tvOS", "tvos")
1573 .Case("watchOS", "watchos")
1574 .Case("iOSApplicationExtension", "ios_app_extension")
1575 .Case("macOSApplicationExtension", "macos_app_extension")
1576 .Case("tvOSApplicationExtension", "tvos_app_extension")
1577 .Case("watchOSApplicationExtension", "watchos_app_extension")
1578 .Default(Platform);
1579}
1580
1581 static bool classof(const Attr *A) { return A->getKind() == attr::Availability; }
1582};
1583
1584class BlocksAttr : public InheritableAttr {
1585public:
1586 enum BlockType {
1587 ByRef
1588 };
1589private:
1590 BlockType type;
1591
1592public:
1593 static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Loc = SourceRange()) {
1594 auto *A = new (Ctx) BlocksAttr(Loc, Ctx, Type, 0);
1595 A->setImplicit(true);
1596 return A;
1597 }
1598
1599 BlocksAttr(SourceRange R, ASTContext &Ctx
1600 , BlockType Type
1601 , unsigned SI
1602 )
1603 : InheritableAttr(attr::Blocks, R, SI, false, false)
1604 , type(Type)
1605 {
1606 }
1607
1608 BlocksAttr *clone(ASTContext &C) const;
1609 void printPretty(raw_ostream &OS,
1610 const PrintingPolicy &Policy) const;
1611 const char *getSpelling() const;
1612 BlockType getType() const {
1613 return type;
1614 }
1615
1616 static bool ConvertStrToBlockType(StringRef Val, BlockType &Out) {
1617 Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val)
1618 .Case("byref", BlocksAttr::ByRef)
1619 .Default(Optional<BlockType>());
1620 if (R) {
1621 Out = *R;
1622 return true;
1623 }
1624 return false;
1625 }
1626
1627 static const char *ConvertBlockTypeToStr(BlockType Val) {
1628 switch(Val) {
1629 case BlocksAttr::ByRef: return "byref";
1630 }
1631 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1631)
;
1632 }
1633
1634
1635 static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; }
1636};
1637
1638class C11NoReturnAttr : public InheritableAttr {
1639public:
1640 static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1641 auto *A = new (Ctx) C11NoReturnAttr(Loc, Ctx, 0);
1642 A->setImplicit(true);
1643 return A;
1644 }
1645
1646 C11NoReturnAttr(SourceRange R, ASTContext &Ctx
1647 , unsigned SI
1648 )
1649 : InheritableAttr(attr::C11NoReturn, R, SI, false, false)
1650 {
1651 }
1652
1653 C11NoReturnAttr *clone(ASTContext &C) const;
1654 void printPretty(raw_ostream &OS,
1655 const PrintingPolicy &Policy) const;
1656 const char *getSpelling() const;
1657
1658
1659 static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; }
1660};
1661
1662class CDeclAttr : public InheritableAttr {
1663public:
1664 static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1665 auto *A = new (Ctx) CDeclAttr(Loc, Ctx, 0);
1666 A->setImplicit(true);
1667 return A;
1668 }
1669
1670 CDeclAttr(SourceRange R, ASTContext &Ctx
1671 , unsigned SI
1672 )
1673 : InheritableAttr(attr::CDecl, R, SI, false, false)
1674 {
1675 }
1676
1677 CDeclAttr *clone(ASTContext &C) const;
1678 void printPretty(raw_ostream &OS,
1679 const PrintingPolicy &Policy) const;
1680 const char *getSpelling() const;
1681
1682
1683 static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; }
1684};
1685
1686class CFAuditedTransferAttr : public InheritableAttr {
1687public:
1688 static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1689 auto *A = new (Ctx) CFAuditedTransferAttr(Loc, Ctx, 0);
1690 A->setImplicit(true);
1691 return A;
1692 }
1693
1694 CFAuditedTransferAttr(SourceRange R, ASTContext &Ctx
1695 , unsigned SI
1696 )
1697 : InheritableAttr(attr::CFAuditedTransfer, R, SI, false, false)
1698 {
1699 }
1700
1701 CFAuditedTransferAttr *clone(ASTContext &C) const;
1702 void printPretty(raw_ostream &OS,
1703 const PrintingPolicy &Policy) const;
1704 const char *getSpelling() const;
1705
1706
1707 static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; }
1708};
1709
1710class CFConsumedAttr : public InheritableParamAttr {
1711public:
1712 static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1713 auto *A = new (Ctx) CFConsumedAttr(Loc, Ctx, 0);
1714 A->setImplicit(true);
1715 return A;
1716 }
1717
1718 CFConsumedAttr(SourceRange R, ASTContext &Ctx
1719 , unsigned SI
1720 )
1721 : InheritableParamAttr(attr::CFConsumed, R, SI, false, false)
1722 {
1723 }
1724
1725 CFConsumedAttr *clone(ASTContext &C) const;
1726 void printPretty(raw_ostream &OS,
1727 const PrintingPolicy &Policy) const;
1728 const char *getSpelling() const;
1729
1730
1731 static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; }
1732};
1733
1734class CFReturnsNotRetainedAttr : public InheritableAttr {
1735public:
1736 static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1737 auto *A = new (Ctx) CFReturnsNotRetainedAttr(Loc, Ctx, 0);
1738 A->setImplicit(true);
1739 return A;
1740 }
1741
1742 CFReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
1743 , unsigned SI
1744 )
1745 : InheritableAttr(attr::CFReturnsNotRetained, R, SI, false, false)
1746 {
1747 }
1748
1749 CFReturnsNotRetainedAttr *clone(ASTContext &C) const;
1750 void printPretty(raw_ostream &OS,
1751 const PrintingPolicy &Policy) const;
1752 const char *getSpelling() const;
1753
1754
1755 static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; }
1756};
1757
1758class CFReturnsRetainedAttr : public InheritableAttr {
1759public:
1760 static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1761 auto *A = new (Ctx) CFReturnsRetainedAttr(Loc, Ctx, 0);
1762 A->setImplicit(true);
1763 return A;
1764 }
1765
1766 CFReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
1767 , unsigned SI
1768 )
1769 : InheritableAttr(attr::CFReturnsRetained, R, SI, false, false)
1770 {
1771 }
1772
1773 CFReturnsRetainedAttr *clone(ASTContext &C) const;
1774 void printPretty(raw_ostream &OS,
1775 const PrintingPolicy &Policy) const;
1776 const char *getSpelling() const;
1777
1778
1779 static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; }
1780};
1781
1782class CFUnknownTransferAttr : public InheritableAttr {
1783public:
1784 static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1785 auto *A = new (Ctx) CFUnknownTransferAttr(Loc, Ctx, 0);
1786 A->setImplicit(true);
1787 return A;
1788 }
1789
1790 CFUnknownTransferAttr(SourceRange R, ASTContext &Ctx
1791 , unsigned SI
1792 )
1793 : InheritableAttr(attr::CFUnknownTransfer, R, SI, false, false)
1794 {
1795 }
1796
1797 CFUnknownTransferAttr *clone(ASTContext &C) const;
1798 void printPretty(raw_ostream &OS,
1799 const PrintingPolicy &Policy) const;
1800 const char *getSpelling() const;
1801
1802
1803 static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; }
1804};
1805
1806class CPUDispatchAttr : public InheritableAttr {
1807 unsigned cpus_Size;
1808 IdentifierInfo * *cpus_;
1809
1810public:
1811 static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) {
1812 auto *A = new (Ctx) CPUDispatchAttr(Loc, Ctx, Cpus, CpusSize, 0);
1813 A->setImplicit(true);
1814 return A;
1815 }
1816
1817 CPUDispatchAttr(SourceRange R, ASTContext &Ctx
1818 , IdentifierInfo * *Cpus, unsigned CpusSize
1819 , unsigned SI
1820 )
1821 : InheritableAttr(attr::CPUDispatch, R, SI, false, false)
1822 , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size])
1823 {
1824 std::copy(Cpus, Cpus + cpus_Size, cpus_);
1825 }
1826
1827 CPUDispatchAttr(SourceRange R, ASTContext &Ctx
1828 , unsigned SI
1829 )
1830 : InheritableAttr(attr::CPUDispatch, R, SI, false, false)
1831 , cpus_Size(0), cpus_(nullptr)
1832 {
1833 }
1834
1835 CPUDispatchAttr *clone(ASTContext &C) const;
1836 void printPretty(raw_ostream &OS,
1837 const PrintingPolicy &Policy) const;
1838 const char *getSpelling() const;
1839 typedef IdentifierInfo ** cpus_iterator;
1840 cpus_iterator cpus_begin() const { return cpus_; }
1841 cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
1842 unsigned cpus_size() const { return cpus_Size; }
1843 llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }
1844
1845
1846
1847
1848 static bool classof(const Attr *A) { return A->getKind() == attr::CPUDispatch; }
1849};
1850
1851class CPUSpecificAttr : public InheritableAttr {
1852 unsigned cpus_Size;
1853 IdentifierInfo * *cpus_;
1854
1855public:
1856 static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) {
1857 auto *A = new (Ctx) CPUSpecificAttr(Loc, Ctx, Cpus, CpusSize, 0);
1858 A->setImplicit(true);
1859 return A;
1860 }
1861
1862 CPUSpecificAttr(SourceRange R, ASTContext &Ctx
1863 , IdentifierInfo * *Cpus, unsigned CpusSize
1864 , unsigned SI
1865 )
1866 : InheritableAttr(attr::CPUSpecific, R, SI, false, false)
1867 , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size])
1868 {
1869 std::copy(Cpus, Cpus + cpus_Size, cpus_);
1870 }
1871
1872 CPUSpecificAttr(SourceRange R, ASTContext &Ctx
1873 , unsigned SI
1874 )
1875 : InheritableAttr(attr::CPUSpecific, R, SI, false, false)
1876 , cpus_Size(0), cpus_(nullptr)
1877 {
1878 }
1879
1880 CPUSpecificAttr *clone(ASTContext &C) const;
1881 void printPretty(raw_ostream &OS,
1882 const PrintingPolicy &Policy) const;
1883 const char *getSpelling() const;
1884 typedef IdentifierInfo ** cpus_iterator;
1885 cpus_iterator cpus_begin() const { return cpus_; }
1886 cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
1887 unsigned cpus_size() const { return cpus_Size; }
1888 llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }
1889
1890
1891
1892 IdentifierInfo *getCPUName(unsigned Index) const {
1893 return *(cpus_begin() + Index);
1894 }
1895
1896
1897 static bool classof(const Attr *A) { return A->getKind() == attr::CPUSpecific; }
1898};
1899
1900class CUDAConstantAttr : public InheritableAttr {
1901public:
1902 static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1903 auto *A = new (Ctx) CUDAConstantAttr(Loc, Ctx, 0);
1904 A->setImplicit(true);
1905 return A;
1906 }
1907
1908 CUDAConstantAttr(SourceRange R, ASTContext &Ctx
1909 , unsigned SI
1910 )
1911 : InheritableAttr(attr::CUDAConstant, R, SI, false, false)
1912 {
1913 }
1914
1915 CUDAConstantAttr *clone(ASTContext &C) const;
1916 void printPretty(raw_ostream &OS,
1917 const PrintingPolicy &Policy) const;
1918 const char *getSpelling() const;
1919
1920
1921 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; }
1922};
1923
1924class CUDADeviceAttr : public InheritableAttr {
1925public:
1926 static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1927 auto *A = new (Ctx) CUDADeviceAttr(Loc, Ctx, 0);
1928 A->setImplicit(true);
1929 return A;
1930 }
1931
1932 CUDADeviceAttr(SourceRange R, ASTContext &Ctx
1933 , unsigned SI
1934 )
1935 : InheritableAttr(attr::CUDADevice, R, SI, false, false)
1936 {
1937 }
1938
1939 CUDADeviceAttr *clone(ASTContext &C) const;
1940 void printPretty(raw_ostream &OS,
1941 const PrintingPolicy &Policy) const;
1942 const char *getSpelling() const;
1943
1944
1945 static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; }
1946};
1947
1948class CUDAGlobalAttr : public InheritableAttr {
1949public:
1950 static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1951 auto *A = new (Ctx) CUDAGlobalAttr(Loc, Ctx, 0);
1952 A->setImplicit(true);
1953 return A;
1954 }
1955
1956 CUDAGlobalAttr(SourceRange R, ASTContext &Ctx
1957 , unsigned SI
1958 )
1959 : InheritableAttr(attr::CUDAGlobal, R, SI, false, false)
1960 {
1961 }
1962
1963 CUDAGlobalAttr *clone(ASTContext &C) const;
1964 void printPretty(raw_ostream &OS,
1965 const PrintingPolicy &Policy) const;
1966 const char *getSpelling() const;
1967
1968
1969 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; }
1970};
1971
1972class CUDAHostAttr : public InheritableAttr {
1973public:
1974 static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1975 auto *A = new (Ctx) CUDAHostAttr(Loc, Ctx, 0);
1976 A->setImplicit(true);
1977 return A;
1978 }
1979
1980 CUDAHostAttr(SourceRange R, ASTContext &Ctx
1981 , unsigned SI
1982 )
1983 : InheritableAttr(attr::CUDAHost, R, SI, false, false)
1984 {
1985 }
1986
1987 CUDAHostAttr *clone(ASTContext &C) const;
1988 void printPretty(raw_ostream &OS,
1989 const PrintingPolicy &Policy) const;
1990 const char *getSpelling() const;
1991
1992
1993 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; }
1994};
1995
1996class CUDAInvalidTargetAttr : public InheritableAttr {
1997public:
1998 static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1999 auto *A = new (Ctx) CUDAInvalidTargetAttr(Loc, Ctx, 0);
2000 A->setImplicit(true);
2001 return A;
2002 }
2003
2004 CUDAInvalidTargetAttr(SourceRange R, ASTContext &Ctx
2005 , unsigned SI
2006 )
2007 : InheritableAttr(attr::CUDAInvalidTarget, R, SI, false, false)
2008 {
2009 }
2010
2011 CUDAInvalidTargetAttr *clone(ASTContext &C) const;
2012 void printPretty(raw_ostream &OS,
2013 const PrintingPolicy &Policy) const;
2014 const char *getSpelling() const;
2015
2016
2017 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; }
2018};
2019
2020class CUDALaunchBoundsAttr : public InheritableAttr {
2021Expr * maxThreads;
2022
2023Expr * minBlocks;
2024
2025public:
2026 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Loc = SourceRange()) {
2027 auto *A = new (Ctx) CUDALaunchBoundsAttr(Loc, Ctx, MaxThreads, MinBlocks, 0);
2028 A->setImplicit(true);
2029 return A;
2030 }
2031
2032 CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
2033 , Expr * MaxThreads
2034 , Expr * MinBlocks
2035 , unsigned SI
2036 )
2037 : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false)
2038 , maxThreads(MaxThreads)
2039 , minBlocks(MinBlocks)
2040 {
2041 }
2042
2043 CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
2044 , Expr * MaxThreads
2045 , unsigned SI
2046 )
2047 : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false)
2048 , maxThreads(MaxThreads)
2049 , minBlocks()
2050 {
2051 }
2052
2053 CUDALaunchBoundsAttr *clone(ASTContext &C) const;
2054 void printPretty(raw_ostream &OS,
2055 const PrintingPolicy &Policy) const;
2056 const char *getSpelling() const;
2057 Expr * getMaxThreads() const {
2058 return maxThreads;
2059 }
2060
2061 Expr * getMinBlocks() const {
2062 return minBlocks;
2063 }
2064
2065
2066
2067 static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; }
2068};
2069
2070class CUDASharedAttr : public InheritableAttr {
2071public:
2072 static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2073 auto *A = new (Ctx) CUDASharedAttr(Loc, Ctx, 0);
2074 A->setImplicit(true);
2075 return A;
2076 }
2077
2078 CUDASharedAttr(SourceRange R, ASTContext &Ctx
2079 , unsigned SI
2080 )
2081 : InheritableAttr(attr::CUDAShared, R, SI, false, false)
2082 {
2083 }
2084
2085 CUDASharedAttr *clone(ASTContext &C) const;
2086 void printPretty(raw_ostream &OS,
2087 const PrintingPolicy &Policy) const;
2088 const char *getSpelling() const;
2089
2090
2091 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; }
2092};
2093
2094class CXX11NoReturnAttr : public InheritableAttr {
2095public:
2096 static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2097 auto *A = new (Ctx) CXX11NoReturnAttr(Loc, Ctx, 0);
2098 A->setImplicit(true);
2099 return A;
2100 }
2101
2102 CXX11NoReturnAttr(SourceRange R, ASTContext &Ctx
2103 , unsigned SI
2104 )
2105 : InheritableAttr(attr::CXX11NoReturn, R, SI, false, false)
2106 {
2107 }
2108
2109 CXX11NoReturnAttr *clone(ASTContext &C) const;
2110 void printPretty(raw_ostream &OS,
2111 const PrintingPolicy &Policy) const;
2112 const char *getSpelling() const;
2113
2114
2115 static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; }
2116};
2117
2118class CallableWhenAttr : public InheritableAttr {
2119public:
2120 enum ConsumedState {
2121 Unknown,
2122 Consumed,
2123 Unconsumed
2124 };
2125private:
2126 unsigned callableStates_Size;
2127 ConsumedState *callableStates_;
2128
2129public:
2130 static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Loc = SourceRange()) {
2131 auto *A = new (Ctx) CallableWhenAttr(Loc, Ctx, CallableStates, CallableStatesSize, 0);
2132 A->setImplicit(true);
2133 return A;
2134 }
2135
2136 CallableWhenAttr(SourceRange R, ASTContext &Ctx
2137 , ConsumedState *CallableStates, unsigned CallableStatesSize
2138 , unsigned SI
2139 )
2140 : InheritableAttr(attr::CallableWhen, R, SI, false, false)
2141 , callableStates_Size(CallableStatesSize), callableStates_(new (Ctx, 16) ConsumedState[callableStates_Size])
2142 {
2143 std::copy(CallableStates, CallableStates + callableStates_Size, callableStates_);
2144 }
2145
2146 CallableWhenAttr(SourceRange R, ASTContext &Ctx
2147 , unsigned SI
2148 )
2149 : InheritableAttr(attr::CallableWhen, R, SI, false, false)
2150 , callableStates_Size(0), callableStates_(nullptr)
2151 {
2152 }
2153
2154 CallableWhenAttr *clone(ASTContext &C) const;
2155 void printPretty(raw_ostream &OS,
2156 const PrintingPolicy &Policy) const;
2157 const char *getSpelling() const;
2158 typedef ConsumedState* callableStates_iterator;
2159 callableStates_iterator callableStates_begin() const { return callableStates_; }
2160 callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; }
2161 unsigned callableStates_size() const { return callableStates_Size; }
2162 llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); }
2163
2164
2165 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
2166 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
2167 .Case("unknown", CallableWhenAttr::Unknown)
2168 .Case("consumed", CallableWhenAttr::Consumed)
2169 .Case("unconsumed", CallableWhenAttr::Unconsumed)
2170 .Default(Optional<ConsumedState>());
2171 if (R) {
2172 Out = *R;
2173 return true;
2174 }
2175 return false;
2176 }
2177
2178 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
2179 switch(Val) {
2180 case CallableWhenAttr::Unknown: return "unknown";
2181 case CallableWhenAttr::Consumed: return "consumed";
2182 case CallableWhenAttr::Unconsumed: return "unconsumed";
2183 }
2184 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2184)
;
2185 }
2186
2187
2188 static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; }
2189};
2190
2191class CallbackAttr : public InheritableAttr {
2192 unsigned encoding_Size;
2193 int *encoding_;
2194
2195public:
2196 static CallbackAttr *CreateImplicit(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, SourceRange Loc = SourceRange()) {
2197 auto *A = new (Ctx) CallbackAttr(Loc, Ctx, Encoding, EncodingSize, 0);
2198 A->setImplicit(true);
2199 return A;
2200 }
2201
2202 CallbackAttr(SourceRange R, ASTContext &Ctx
2203 , int *Encoding, unsigned EncodingSize
2204 , unsigned SI
2205 )
2206 : InheritableAttr(attr::Callback, R, SI, false, false)
2207 , encoding_Size(EncodingSize), encoding_(new (Ctx, 16) int[encoding_Size])
2208 {
2209 std::copy(Encoding, Encoding + encoding_Size, encoding_);
2210 }
2211
2212 CallbackAttr(SourceRange R, ASTContext &Ctx
2213 , unsigned SI
2214 )
2215 : InheritableAttr(attr::Callback, R, SI, false, false)
2216 , encoding_Size(0), encoding_(nullptr)
2217 {
2218 }
2219
2220 CallbackAttr *clone(ASTContext &C) const;
2221 void printPretty(raw_ostream &OS,
2222 const PrintingPolicy &Policy) const;
2223 const char *getSpelling() const;
2224 typedef int* encoding_iterator;
2225 encoding_iterator encoding_begin() const { return encoding_; }
2226 encoding_iterator encoding_end() const { return encoding_ + encoding_Size; }
2227 unsigned encoding_size() const { return encoding_Size; }
2228 llvm::iterator_range<encoding_iterator> encoding() const { return llvm::make_range(encoding_begin(), encoding_end()); }
2229
2230
2231
2232
2233 static bool classof(const Attr *A) { return A->getKind() == attr::Callback; }
2234};
2235
2236class CapabilityAttr : public InheritableAttr {
2237unsigned nameLength;
2238char *name;
2239
2240public:
2241 enum Spelling {
2242 GNU_capability = 0,
2243 CXX11_clang_capability = 1,
2244 GNU_shared_capability = 2,
2245 CXX11_clang_shared_capability = 3
2246 };
2247
2248 static CapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
2249 auto *A = new (Ctx) CapabilityAttr(Loc, Ctx, Name, S);
2250 A->setImplicit(true);
2251 return A;
2252 }
2253
2254 CapabilityAttr(SourceRange R, ASTContext &Ctx
2255 , llvm::StringRef Name
2256 , unsigned SI
2257 )
2258 : InheritableAttr(attr::Capability, R, SI, false, false)
2259 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
2260 {
2261 if (!Name.empty())
2262 std::memcpy(name, Name.data(), nameLength);
2263 }
2264
2265 CapabilityAttr *clone(ASTContext &C) const;
2266 void printPretty(raw_ostream &OS,
2267 const PrintingPolicy &Policy) const;
2268 const char *getSpelling() const;
2269 Spelling getSemanticSpelling() const {
2270 switch (SpellingListIndex) {
2271 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2271)
;
2272 case 0: return GNU_capability;
2273 case 1: return CXX11_clang_capability;
2274 case 2: return GNU_shared_capability;
2275 case 3: return CXX11_clang_shared_capability;
2276 }
2277 }
2278 bool isShared() const { return SpellingListIndex == 2 ||
2279 SpellingListIndex == 3; }
2280 llvm::StringRef getName() const {
2281 return llvm::StringRef(name, nameLength);
2282 }
2283 unsigned getNameLength() const {
2284 return nameLength;
2285 }
2286 void setName(ASTContext &C, llvm::StringRef S) {
2287 nameLength = S.size();
2288 this->name = new (C, 1) char [nameLength];
2289 if (!S.empty())
2290 std::memcpy(this->name, S.data(), nameLength);
2291 }
2292
2293
2294 bool isMutex() const { return getName().equals_lower("mutex"); }
2295 bool isRole() const { return getName().equals_lower("role"); }
2296
2297
2298 static bool classof(const Attr *A) { return A->getKind() == attr::Capability; }
2299};
2300
2301class CapturedRecordAttr : public InheritableAttr {
2302public:
2303 static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2304 auto *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0);
2305 A->setImplicit(true);
2306 return A;
2307 }
2308
2309 CapturedRecordAttr(SourceRange R, ASTContext &Ctx
2310 , unsigned SI
2311 )
2312 : InheritableAttr(attr::CapturedRecord, R, SI, false, false)
2313 {
2314 }
2315
2316 CapturedRecordAttr *clone(ASTContext &C) const;
2317 void printPretty(raw_ostream &OS,
2318 const PrintingPolicy &Policy) const;
2319 const char *getSpelling() const;
2320
2321
2322 static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; }
2323};
2324
2325class CarriesDependencyAttr : public InheritableParamAttr {
2326public:
2327 static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2328 auto *A = new (Ctx) CarriesDependencyAttr(Loc, Ctx, 0);
2329 A->setImplicit(true);
2330 return A;
2331 }
2332
2333 CarriesDependencyAttr(SourceRange R, ASTContext &Ctx
2334 , unsigned SI
2335 )
2336 : InheritableParamAttr(attr::CarriesDependency, R, SI, false, false)
2337 {
2338 }
2339
2340 CarriesDependencyAttr *clone(ASTContext &C) const;
2341 void printPretty(raw_ostream &OS,
2342 const PrintingPolicy &Policy) const;
2343 const char *getSpelling() const;
2344
2345
2346 static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; }
2347};
2348
2349class CleanupAttr : public InheritableAttr {
2350FunctionDecl * functionDecl;
2351
2352public:
2353 static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Loc = SourceRange()) {
2354 auto *A = new (Ctx) CleanupAttr(Loc, Ctx, FunctionDecl, 0);
2355 A->setImplicit(true);
2356 return A;
2357 }
2358
2359 CleanupAttr(SourceRange R, ASTContext &Ctx
2360 , FunctionDecl * FunctionDecl
2361 , unsigned SI
2362 )
2363 : InheritableAttr(attr::Cleanup, R, SI, false, false)
2364 , functionDecl(FunctionDecl)
2365 {
2366 }
2367
2368 CleanupAttr *clone(ASTContext &C) const;
2369 void printPretty(raw_ostream &OS,
2370 const PrintingPolicy &Policy) const;
2371 const char *getSpelling() const;
2372 FunctionDecl * getFunctionDecl() const {
2373 return functionDecl;
2374 }
2375
2376
2377
2378 static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; }
2379};
2380
2381class CodeSegAttr : public InheritableAttr {
2382unsigned nameLength;
2383char *name;
2384
2385public:
2386 static CodeSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
2387 auto *A = new (Ctx) CodeSegAttr(Loc, Ctx, Name, 0);
2388 A->setImplicit(true);
2389 return A;
2390 }
2391
2392 CodeSegAttr(SourceRange R, ASTContext &Ctx
2393 , llvm::StringRef Name
2394 , unsigned SI
2395 )
2396 : InheritableAttr(attr::CodeSeg, R, SI, false, false)
2397 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
2398 {
2399 if (!Name.empty())
2400 std::memcpy(name, Name.data(), nameLength);
2401 }
2402
2403 CodeSegAttr *clone(ASTContext &C) const;
2404 void printPretty(raw_ostream &OS,
2405 const PrintingPolicy &Policy) const;
2406 const char *getSpelling() const;
2407 llvm::StringRef getName() const {
2408 return llvm::StringRef(name, nameLength);
2409 }
2410 unsigned getNameLength() const {
2411 return nameLength;
2412 }
2413 void setName(ASTContext &C, llvm::StringRef S) {
2414 nameLength = S.size();
2415 this->name = new (C, 1) char [nameLength];
2416 if (!S.empty())
2417 std::memcpy(this->name, S.data(), nameLength);
2418 }
2419
2420
2421
2422 static bool classof(const Attr *A) { return A->getKind() == attr::CodeSeg; }
2423};
2424
2425class ColdAttr : public InheritableAttr {
2426public:
2427 static ColdAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2428 auto *A = new (Ctx) ColdAttr(Loc, Ctx, 0);
2429 A->setImplicit(true);
2430 return A;
2431 }
2432
2433 ColdAttr(SourceRange R, ASTContext &Ctx
2434 , unsigned SI
2435 )
2436 : InheritableAttr(attr::Cold, R, SI, false, false)
2437 {
2438 }
2439
2440 ColdAttr *clone(ASTContext &C) const;
2441 void printPretty(raw_ostream &OS,
2442 const PrintingPolicy &Policy) const;
2443 const char *getSpelling() const;
2444
2445
2446 static bool classof(const Attr *A) { return A->getKind() == attr::Cold; }
2447};
2448
2449class CommonAttr : public InheritableAttr {
2450public:
2451 static CommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2452 auto *A = new (Ctx) CommonAttr(Loc, Ctx, 0);
2453 A->setImplicit(true);
2454 return A;
2455 }
2456
2457 CommonAttr(SourceRange R, ASTContext &Ctx
2458 , unsigned SI
2459 )
2460 : InheritableAttr(attr::Common, R, SI, false, false)
2461 {
2462 }
2463
2464 CommonAttr *clone(ASTContext &C) const;
2465 void printPretty(raw_ostream &OS,
2466 const PrintingPolicy &Policy) const;
2467 const char *getSpelling() const;
2468
2469
2470 static bool classof(const Attr *A) { return A->getKind() == attr::Common; }
2471};
2472
2473class ConstAttr : public InheritableAttr {
2474public:
2475 static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2476 auto *A = new (Ctx) ConstAttr(Loc, Ctx, 0);
2477 A->setImplicit(true);
2478 return A;
2479 }
2480
2481 ConstAttr(SourceRange R, ASTContext &Ctx
2482 , unsigned SI
2483 )
2484 : InheritableAttr(attr::Const, R, SI, false, false)
2485 {
2486 }
2487
2488 ConstAttr *clone(ASTContext &C) const;
2489 void printPretty(raw_ostream &OS,
2490 const PrintingPolicy &Policy) const;
2491 const char *getSpelling() const;
2492
2493
2494 static bool classof(const Attr *A) { return A->getKind() == attr::Const; }
2495};
2496
2497class ConstructorAttr : public InheritableAttr {
2498int priority;
2499
2500public:
2501 static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
2502 auto *A = new (Ctx) ConstructorAttr(Loc, Ctx, Priority, 0);
2503 A->setImplicit(true);
2504 return A;
2505 }
2506
2507 ConstructorAttr(SourceRange R, ASTContext &Ctx
2508 , int Priority
2509 , unsigned SI
2510 )
2511 : InheritableAttr(attr::Constructor, R, SI, false, false)
2512 , priority(Priority)
2513 {
2514 }
2515
2516 ConstructorAttr(SourceRange R, ASTContext &Ctx
2517 , unsigned SI
2518 )
2519 : InheritableAttr(attr::Constructor, R, SI, false, false)
2520 , priority()
2521 {
2522 }
2523
2524 ConstructorAttr *clone(ASTContext &C) const;
2525 void printPretty(raw_ostream &OS,
2526 const PrintingPolicy &Policy) const;
2527 const char *getSpelling() const;
2528 int getPriority() const {
2529 return priority;
2530 }
2531
2532 static const int DefaultPriority = 65535;
2533
2534
2535
2536 static bool classof(const Attr *A) { return A->getKind() == attr::Constructor; }
2537};
2538
2539class ConsumableAttr : public InheritableAttr {
2540public:
2541 enum ConsumedState {
2542 Unknown,
2543 Consumed,
2544 Unconsumed
2545 };
2546private:
2547 ConsumedState defaultState;
2548
2549public:
2550 static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumedState DefaultState, SourceRange Loc = SourceRange()) {
2551 auto *A = new (Ctx) ConsumableAttr(Loc, Ctx, DefaultState, 0);
2552 A->setImplicit(true);
2553 return A;
2554 }
2555
2556 ConsumableAttr(SourceRange R, ASTContext &Ctx
2557 , ConsumedState DefaultState
2558 , unsigned SI
2559 )
2560 : InheritableAttr(attr::Consumable, R, SI, false, false)
2561 , defaultState(DefaultState)
2562 {
2563 }
2564
2565 ConsumableAttr *clone(ASTContext &C) const;
2566 void printPretty(raw_ostream &OS,
2567 const PrintingPolicy &Policy) const;
2568 const char *getSpelling() const;
2569 ConsumedState getDefaultState() const {
2570 return defaultState;
2571 }
2572
2573 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
2574 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
2575 .Case("unknown", ConsumableAttr::Unknown)
2576 .Case("consumed", ConsumableAttr::Consumed)
2577 .Case("unconsumed", ConsumableAttr::Unconsumed)
2578 .Default(Optional<ConsumedState>());
2579 if (R) {
2580 Out = *R;
2581 return true;
2582 }
2583 return false;
2584 }
2585
2586 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
2587 switch(Val) {
2588 case ConsumableAttr::Unknown: return "unknown";
2589 case ConsumableAttr::Consumed: return "consumed";
2590 case ConsumableAttr::Unconsumed: return "unconsumed";
2591 }
2592 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2592)
;
2593 }
2594
2595
2596 static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; }
2597};
2598
2599class ConsumableAutoCastAttr : public InheritableAttr {
2600public:
2601 static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2602 auto *A = new (Ctx) ConsumableAutoCastAttr(Loc, Ctx, 0);
2603 A->setImplicit(true);
2604 return A;
2605 }
2606
2607 ConsumableAutoCastAttr(SourceRange R, ASTContext &Ctx
2608 , unsigned SI
2609 )
2610 : InheritableAttr(attr::ConsumableAutoCast, R, SI, false, false)
2611 {
2612 }
2613
2614 ConsumableAutoCastAttr *clone(ASTContext &C) const;
2615 void printPretty(raw_ostream &OS,
2616 const PrintingPolicy &Policy) const;
2617 const char *getSpelling() const;
2618
2619
2620 static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableAutoCast; }
2621};
2622
2623class ConsumableSetOnReadAttr : public InheritableAttr {
2624public:
2625 static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2626 auto *A = new (Ctx) ConsumableSetOnReadAttr(Loc, Ctx, 0);
2627 A->setImplicit(true);
2628 return A;
2629 }
2630
2631 ConsumableSetOnReadAttr(SourceRange R, ASTContext &Ctx
2632 , unsigned SI
2633 )
2634 : InheritableAttr(attr::ConsumableSetOnRead, R, SI, false, false)
2635 {
2636 }
2637
2638 ConsumableSetOnReadAttr *clone(ASTContext &C) const;
2639 void printPretty(raw_ostream &OS,
2640 const PrintingPolicy &Policy) const;
2641 const char *getSpelling() const;
2642
2643
2644 static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableSetOnRead; }
2645};
2646
2647class ConvergentAttr : public InheritableAttr {
2648public:
2649 static ConvergentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2650 auto *A = new (Ctx) ConvergentAttr(Loc, Ctx, 0);
2651 A->setImplicit(true);
2652 return A;
2653 }
2654
2655 ConvergentAttr(SourceRange R, ASTContext &Ctx
2656 , unsigned SI
2657 )
2658 : InheritableAttr(attr::Convergent, R, SI, false, false)
2659 {
2660 }
2661
2662 ConvergentAttr *clone(ASTContext &C) const;
2663 void printPretty(raw_ostream &OS,
2664 const PrintingPolicy &Policy) const;
2665 const char *getSpelling() const;
2666
2667
2668 static bool classof(const Attr *A) { return A->getKind() == attr::Convergent; }
2669};
2670
2671class DLLExportAttr : public InheritableAttr {
2672public:
2673 static DLLExportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2674 auto *A = new (Ctx) DLLExportAttr(Loc, Ctx, 0);
2675 A->setImplicit(true);
2676 return A;
2677 }
2678
2679 DLLExportAttr(SourceRange R, ASTContext &Ctx
2680 , unsigned SI
2681 )
2682 : InheritableAttr(attr::DLLExport, R, SI, false, false)
2683 {
2684 }
2685
2686 DLLExportAttr *clone(ASTContext &C) const;
2687 void printPretty(raw_ostream &OS,
2688 const PrintingPolicy &Policy) const;
2689 const char *getSpelling() const;
2690
2691
2692 static bool classof(const Attr *A) { return A->getKind() == attr::DLLExport; }
2693};
2694
2695class DLLExportStaticLocalAttr : public InheritableAttr {
2696public:
2697 static DLLExportStaticLocalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2698 auto *A = new (Ctx) DLLExportStaticLocalAttr(Loc, Ctx, 0);
2699 A->setImplicit(true);
2700 return A;
2701 }
2702
2703 DLLExportStaticLocalAttr(SourceRange R, ASTContext &Ctx
2704 , unsigned SI
2705 )
2706 : InheritableAttr(attr::DLLExportStaticLocal, R, SI, false, false)
2707 {
2708 }
2709
2710 DLLExportStaticLocalAttr *clone(ASTContext &C) const;
2711 void printPretty(raw_ostream &OS,
2712 const PrintingPolicy &Policy) const;
2713 const char *getSpelling() const;
2714
2715
2716 static bool classof(const Attr *A) { return A->getKind() == attr::DLLExportStaticLocal; }
2717};
2718
2719class DLLImportAttr : public InheritableAttr {
2720public:
2721 static DLLImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2722 auto *A = new (Ctx) DLLImportAttr(Loc, Ctx, 0);
2723 A->setImplicit(true);
2724 return A;
2725 }
2726
2727 DLLImportAttr(SourceRange R, ASTContext &Ctx
2728 , unsigned SI
2729 )
2730 : InheritableAttr(attr::DLLImport, R, SI, false, false)
2731 {
2732 }
2733
2734 DLLImportAttr *clone(ASTContext &C) const;
2735 void printPretty(raw_ostream &OS,
2736 const PrintingPolicy &Policy) const;
2737 const char *getSpelling() const;
2738
2739private:
2740 bool PropagatedToBaseTemplate = false;
2741
2742public:
2743 void setPropagatedToBaseTemplate() { PropagatedToBaseTemplate = true; }
2744 bool wasPropagatedToBaseTemplate() { return PropagatedToBaseTemplate; }
2745
2746
2747 static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; }
2748};
2749
2750class DLLImportStaticLocalAttr : public InheritableAttr {
2751public:
2752 static DLLImportStaticLocalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2753 auto *A = new (Ctx) DLLImportStaticLocalAttr(Loc, Ctx, 0);
2754 A->setImplicit(true);
2755 return A;
2756 }
2757
2758 DLLImportStaticLocalAttr(SourceRange R, ASTContext &Ctx
2759 , unsigned SI
2760 )
2761 : InheritableAttr(attr::DLLImportStaticLocal, R, SI, false, false)
2762 {
2763 }
2764
2765 DLLImportStaticLocalAttr *clone(ASTContext &C) const;
2766 void printPretty(raw_ostream &OS,
2767 const PrintingPolicy &Policy) const;
2768 const char *getSpelling() const;
2769
2770
2771 static bool classof(const Attr *A) { return A->getKind() == attr::DLLImportStaticLocal; }
2772};
2773
2774class DeprecatedAttr : public InheritableAttr {
2775unsigned messageLength;
2776char *message;
2777
2778unsigned replacementLength;
2779char *replacement;
2780
2781public:
2782 static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) {
2783 auto *A = new (Ctx) DeprecatedAttr(Loc, Ctx, Message, Replacement, 0);
2784 A->setImplicit(true);
2785 return A;
2786 }
2787
2788 DeprecatedAttr(SourceRange R, ASTContext &Ctx
2789 , llvm::StringRef Message
2790 , llvm::StringRef Replacement
2791 , unsigned SI
2792 )
2793 : InheritableAttr(attr::Deprecated, R, SI, false, false)
2794 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2795 , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
2796 {
2797 if (!Message.empty())
2798 std::memcpy(message, Message.data(), messageLength);
2799 if (!Replacement.empty())
2800 std::memcpy(replacement, Replacement.data(), replacementLength);
2801 }
2802
2803 DeprecatedAttr(SourceRange R, ASTContext &Ctx
2804 , unsigned SI
2805 )
2806 : InheritableAttr(attr::Deprecated, R, SI, false, false)
2807 , messageLength(0),message(nullptr)
2808 , replacementLength(0),replacement(nullptr)
2809 {
2810 }
2811
2812 DeprecatedAttr *clone(ASTContext &C) const;
2813 void printPretty(raw_ostream &OS,
2814 const PrintingPolicy &Policy) const;
2815 const char *getSpelling() const;
2816 llvm::StringRef getMessage() const {
2817 return llvm::StringRef(message, messageLength);
2818 }
2819 unsigned getMessageLength() const {
2820 return messageLength;
2821 }
2822 void setMessage(ASTContext &C, llvm::StringRef S) {
2823 messageLength = S.size();
2824 this->message = new (C, 1) char [messageLength];
2825 if (!S.empty())
2826 std::memcpy(this->message, S.data(), messageLength);
2827 }
2828
2829 llvm::StringRef getReplacement() const {
2830 return llvm::StringRef(replacement, replacementLength);
2831 }
2832 unsigned getReplacementLength() const {
2833 return replacementLength;
2834 }
2835 void setReplacement(ASTContext &C, llvm::StringRef S) {
2836 replacementLength = S.size();
2837 this->replacement = new (C, 1) char [replacementLength];
2838 if (!S.empty())
2839 std::memcpy(this->replacement, S.data(), replacementLength);
2840 }
2841
2842
2843
2844 static bool classof(const Attr *A) { return A->getKind() == attr::Deprecated; }
2845};
2846
2847class DestructorAttr : public InheritableAttr {
2848int priority;
2849
2850public:
2851 static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
2852 auto *A = new (Ctx) DestructorAttr(Loc, Ctx, Priority, 0);
2853 A->setImplicit(true);
2854 return A;
2855 }
2856
2857 DestructorAttr(SourceRange R, ASTContext &Ctx
2858 , int Priority
2859 , unsigned SI
2860 )
2861 : InheritableAttr(attr::Destructor, R, SI, false, false)
2862 , priority(Priority)
2863 {
2864 }
2865
2866 DestructorAttr(SourceRange R, ASTContext &Ctx
2867 , unsigned SI
2868 )
2869 : InheritableAttr(attr::Destructor, R, SI, false, false)
2870 , priority()
2871 {
2872 }
2873
2874 DestructorAttr *clone(ASTContext &C) const;
2875 void printPretty(raw_ostream &OS,
2876 const PrintingPolicy &Policy) const;
2877 const char *getSpelling() const;
2878 int getPriority() const {
2879 return priority;
2880 }
2881
2882 static const int DefaultPriority = 65535;
2883
2884
2885
2886 static bool classof(const Attr *A) { return A->getKind() == attr::Destructor; }
2887};
2888
2889class DiagnoseIfAttr : public InheritableAttr {
2890Expr * cond;
2891
2892unsigned messageLength;
2893char *message;
2894
2895public:
2896 enum DiagnosticType {
2897 DT_Error,
2898 DT_Warning
2899 };
2900private:
2901 DiagnosticType diagnosticType;
2902
2903bool argDependent;
2904
2905NamedDecl * parent;
2906
2907public:
2908 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, SourceRange Loc = SourceRange()) {
2909 auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, ArgDependent, Parent, 0);
2910 A->setImplicit(true);
2911 return A;
2912 }
2913
2914 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, SourceRange Loc = SourceRange()) {
2915 auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, 0);
2916 A->setImplicit(true);
2917 return A;
2918 }
2919
2920 DiagnoseIfAttr(SourceRange R, ASTContext &Ctx
2921 , Expr * Cond
2922 , llvm::StringRef Message
2923 , DiagnosticType DiagnosticType
2924 , bool ArgDependent
2925 , NamedDecl * Parent
2926 , unsigned SI
2927 )
2928 : InheritableAttr(attr::DiagnoseIf, R, SI, true, true)
2929 , cond(Cond)
2930 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2931 , diagnosticType(DiagnosticType)
2932 , argDependent(ArgDependent)
2933 , parent(Parent)
2934 {
2935 if (!Message.empty())
2936 std::memcpy(message, Message.data(), messageLength);
2937 }
2938
2939 DiagnoseIfAttr(SourceRange R, ASTContext &Ctx
2940 , Expr * Cond
2941 , llvm::StringRef Message
2942 , DiagnosticType DiagnosticType
2943 , unsigned SI
2944 )
2945 : InheritableAttr(attr::DiagnoseIf, R, SI, true, true)
2946 , cond(Cond)
2947 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2948 , diagnosticType(DiagnosticType)
2949 , argDependent()
2950 , parent()
2951 {
2952 if (!Message.empty())
2953 std::memcpy(message, Message.data(), messageLength);
2954 }
2955
2956 DiagnoseIfAttr *clone(ASTContext &C) const;
2957 void printPretty(raw_ostream &OS,
2958 const PrintingPolicy &Policy) const;
2959 const char *getSpelling() const;
2960 Expr * getCond() const {
2961 return cond;
2962 }
2963
2964 llvm::StringRef getMessage() const {
2965 return llvm::StringRef(message, messageLength);
2966 }
2967 unsigned getMessageLength() const {
2968 return messageLength;
2969 }
2970 void setMessage(ASTContext &C, llvm::StringRef S) {
2971 messageLength = S.size();
2972 this->message = new (C, 1) char [messageLength];
2973 if (!S.empty())
2974 std::memcpy(this->message, S.data(), messageLength);
2975 }
2976
2977 DiagnosticType getDiagnosticType() const {
2978 return diagnosticType;
2979 }
2980
2981 static bool ConvertStrToDiagnosticType(StringRef Val, DiagnosticType &Out) {
2982 Optional<DiagnosticType> R = llvm::StringSwitch<Optional<DiagnosticType>>(Val)
2983 .Case("error", DiagnoseIfAttr::DT_Error)
2984 .Case("warning", DiagnoseIfAttr::DT_Warning)
2985 .Default(Optional<DiagnosticType>());
2986 if (R) {
2987 Out = *R;
2988 return true;
2989 }
2990 return false;
2991 }
2992
2993 static const char *ConvertDiagnosticTypeToStr(DiagnosticType Val) {
2994 switch(Val) {
2995 case DiagnoseIfAttr::DT_Error: return "error";
2996 case DiagnoseIfAttr::DT_Warning: return "warning";
2997 }
2998 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2998)
;
2999 }
3000 bool getArgDependent() const {
3001 return argDependent;
3002 }
3003
3004 NamedDecl * getParent() const {
3005 return parent;
3006 }
3007
3008
3009 bool isError() const { return diagnosticType == DT_Error; }
3010 bool isWarning() const { return diagnosticType == DT_Warning; }
3011
3012
3013 static bool classof(const Attr *A) { return A->getKind() == attr::DiagnoseIf; }
3014};
3015
3016class DisableTailCallsAttr : public InheritableAttr {
3017public:
3018 static DisableTailCallsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3019 auto *A = new (Ctx) DisableTailCallsAttr(Loc, Ctx, 0);
3020 A->setImplicit(true);
3021 return A;
3022 }
3023
3024 DisableTailCallsAttr(SourceRange R, ASTContext &Ctx
3025 , unsigned SI
3026 )
3027 : InheritableAttr(attr::DisableTailCalls, R, SI, false, false)
3028 {
3029 }
3030
3031 DisableTailCallsAttr *clone(ASTContext &C) const;
3032 void printPretty(raw_ostream &OS,
3033 const PrintingPolicy &Policy) const;
3034 const char *getSpelling() const;
3035
3036
3037 static bool classof(const Attr *A) { return A->getKind() == attr::DisableTailCalls; }
3038};
3039
3040class EmptyBasesAttr : public InheritableAttr {
3041public:
3042 static EmptyBasesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3043 auto *A = new (Ctx) EmptyBasesAttr(Loc, Ctx, 0);
3044 A->setImplicit(true);
3045 return A;
3046 }
3047
3048 EmptyBasesAttr(SourceRange R, ASTContext &Ctx
3049 , unsigned SI
3050 )
3051 : InheritableAttr(attr::EmptyBases, R, SI, false, false)
3052 {
3053 }
3054
3055 EmptyBasesAttr *clone(ASTContext &C) const;
3056 void printPretty(raw_ostream &OS,
3057 const PrintingPolicy &Policy) const;
3058 const char *getSpelling() const;
3059
3060
3061 static bool classof(const Attr *A) { return A->getKind() == attr::EmptyBases; }
3062};
3063
3064class EnableIfAttr : public InheritableAttr {
3065Expr * cond;
3066
3067unsigned messageLength;
3068char *message;
3069
3070public:
3071 static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
3072 auto *A = new (Ctx) EnableIfAttr(Loc, Ctx, Cond, Message, 0);
3073 A->setImplicit(true);
3074 return A;
3075 }
3076
3077 EnableIfAttr(SourceRange R, ASTContext &Ctx
3078 , Expr * Cond
3079 , llvm::StringRef Message
3080 , unsigned SI
3081 )
3082 : InheritableAttr(attr::EnableIf, R, SI, false, false)
3083 , cond(Cond)
3084 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
3085 {
3086 if (!Message.empty())
3087 std::memcpy(message, Message.data(), messageLength);
3088 }
3089
3090 EnableIfAttr *clone(ASTContext &C) const;
3091 void printPretty(raw_ostream &OS,
3092 const PrintingPolicy &Policy) const;
3093 const char *getSpelling() const;
3094 Expr * getCond() const {
3095 return cond;
3096 }
3097
3098 llvm::StringRef getMessage() const {
3099 return llvm::StringRef(message, messageLength);
3100 }
3101 unsigned getMessageLength() const {
3102 return messageLength;
3103 }
3104 void setMessage(ASTContext &C, llvm::StringRef S) {
3105 messageLength = S.size();
3106 this->message = new (C, 1) char [messageLength];
3107 if (!S.empty())
3108 std::memcpy(this->message, S.data(), messageLength);
3109 }
3110
3111
3112
3113 static bool classof(const Attr *A) { return A->getKind() == attr::EnableIf; }
3114};
3115
3116class EnumExtensibilityAttr : public InheritableAttr {
3117public:
3118 enum Kind {
3119 Closed,
3120 Open
3121 };
3122private:
3123 Kind extensibility;
3124
3125public:
3126 static EnumExtensibilityAttr *CreateImplicit(ASTContext &Ctx, Kind Extensibility, SourceRange Loc = SourceRange()) {
3127 auto *A = new (Ctx) EnumExtensibilityAttr(Loc, Ctx, Extensibility, 0);
3128 A->setImplicit(true);
3129 return A;
3130 }
3131
3132 EnumExtensibilityAttr(SourceRange R, ASTContext &Ctx
3133 , Kind Extensibility
3134 , unsigned SI
3135 )
3136 : InheritableAttr(attr::EnumExtensibility, R, SI, false, false)
3137 , extensibility(Extensibility)
3138 {
3139 }
3140
3141 EnumExtensibilityAttr *clone(ASTContext &C) const;
3142 void printPretty(raw_ostream &OS,
3143 const PrintingPolicy &Policy) const;
3144 const char *getSpelling() const;
3145 Kind getExtensibility() const {
3146 return extensibility;
3147 }
3148
3149 static bool ConvertStrToKind(StringRef Val, Kind &Out) {
3150 Optional<Kind> R = llvm::StringSwitch<Optional<Kind>>(Val)
3151 .Case("closed", EnumExtensibilityAttr::Closed)
3152 .Case("open", EnumExtensibilityAttr::Open)
3153 .Default(Optional<Kind>());
3154 if (R) {
3155 Out = *R;
3156 return true;
3157 }
3158 return false;
3159 }
3160
3161 static const char *ConvertKindToStr(Kind Val) {
3162 switch(Val) {
3163 case EnumExtensibilityAttr::Closed: return "closed";
3164 case EnumExtensibilityAttr::Open: return "open";
3165 }
3166 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3166)
;
3167 }
3168
3169
3170 static bool classof(const Attr *A) { return A->getKind() == attr::EnumExtensibility; }
3171};
3172
3173class ExcludeFromExplicitInstantiationAttr : public InheritableAttr {
3174public:
3175 static ExcludeFromExplicitInstantiationAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3176 auto *A = new (Ctx) ExcludeFromExplicitInstantiationAttr(Loc, Ctx, 0);
3177 A->setImplicit(true);
3178 return A;
3179 }
3180
3181 ExcludeFromExplicitInstantiationAttr(SourceRange R, ASTContext &Ctx
3182 , unsigned SI
3183 )
3184 : InheritableAttr(attr::ExcludeFromExplicitInstantiation, R, SI, false, false)
3185 {
3186 }
3187
3188 ExcludeFromExplicitInstantiationAttr *clone(ASTContext &C) const;
3189 void printPretty(raw_ostream &OS,
3190 const PrintingPolicy &Policy) const;
3191 const char *getSpelling() const;
3192
3193
3194 static bool classof(const Attr *A) { return A->getKind() == attr::ExcludeFromExplicitInstantiation; }
3195};
3196
3197class ExclusiveTrylockFunctionAttr : public InheritableAttr {
3198Expr * successValue;
3199
3200 unsigned args_Size;
3201 Expr * *args_;
3202
3203public:
3204 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
3205 auto *A = new (Ctx) ExclusiveTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
3206 A->setImplicit(true);
3207 return A;
3208 }
3209
3210 ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
3211 , Expr * SuccessValue
3212 , Expr * *Args, unsigned ArgsSize
3213 , unsigned SI
3214 )
3215 : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true)
3216 , successValue(SuccessValue)
3217 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
3218 {
3219 std::copy(Args, Args + args_Size, args_);
3220 }
3221
3222 ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
3223 , Expr * SuccessValue
3224 , unsigned SI
3225 )
3226 : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true)
3227 , successValue(SuccessValue)
3228 , args_Size(0), args_(nullptr)
3229 {
3230 }
3231
3232 ExclusiveTrylockFunctionAttr *clone(ASTContext &C) const;
3233 void printPretty(raw_ostream &OS,
3234 const PrintingPolicy &Policy) const;
3235 const char *getSpelling() const;
3236 Expr * getSuccessValue() const {
3237 return successValue;
3238 }
3239
3240 typedef Expr ** args_iterator;
3241 args_iterator args_begin() const { return args_; }
3242 args_iterator args_end() const { return args_ + args_Size; }
3243 unsigned args_size() const { return args_Size; }
3244 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
3245
3246
3247
3248
3249 static bool classof(const Attr *A) { return A->getKind() == attr::ExclusiveTrylockFunction; }
3250};
3251
3252class ExternalSourceSymbolAttr : public InheritableAttr {
3253unsigned languageLength;
3254char *language;
3255
3256unsigned definedInLength;
3257char *definedIn;
3258
3259bool generatedDeclaration;
3260
3261public:
3262 static ExternalSourceSymbolAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, SourceRange Loc = SourceRange()) {
3263 auto *A = new (Ctx) ExternalSourceSymbolAttr(Loc, Ctx, Language, DefinedIn, GeneratedDeclaration, 0);
3264 A->setImplicit(true);
3265 return A;
3266 }
3267
3268 ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx
3269 , llvm::StringRef Language
3270 , llvm::StringRef DefinedIn
3271 , bool GeneratedDeclaration
3272 , unsigned SI
3273 )
3274 : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false)
3275 , languageLength(Language.size()),language(new (Ctx, 1) char[languageLength])
3276 , definedInLength(DefinedIn.size()),definedIn(new (Ctx, 1) char[definedInLength])
3277 , generatedDeclaration(GeneratedDeclaration)
3278 {
3279 if (!Language.empty())
3280 std::memcpy(language, Language.data(), languageLength);
3281 if (!DefinedIn.empty())
3282 std::memcpy(definedIn, DefinedIn.data(), definedInLength);
3283 }
3284
3285 ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx
3286 , unsigned SI
3287 )
3288 : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false)
3289 , languageLength(0),language(nullptr)
3290 , definedInLength(0),definedIn(nullptr)
3291 , generatedDeclaration()
3292 {
3293 }
3294
3295 ExternalSourceSymbolAttr *clone(ASTContext &C) const;
3296 void printPretty(raw_ostream &OS,
3297 const PrintingPolicy &Policy) const;
3298 const char *getSpelling() const;
3299 llvm::StringRef getLanguage() const {
3300 return llvm::StringRef(language, languageLength);
3301 }
3302 unsigned getLanguageLength() const {
3303 return languageLength;
3304 }
3305 void setLanguage(ASTContext &C, llvm::StringRef S) {
3306 languageLength = S.size();
3307 this->language = new (C, 1) char [languageLength];
3308 if (!S.empty())
3309 std::memcpy(this->language, S.data(), languageLength);
3310 }
3311
3312 llvm::StringRef getDefinedIn() const {
3313 return llvm::StringRef(definedIn, definedInLength);
3314 }
3315 unsigned getDefinedInLength() const {
3316 return definedInLength;
3317 }
3318 void setDefinedIn(ASTContext &C, llvm::StringRef S) {
3319 definedInLength = S.size();
3320 this->definedIn = new (C, 1) char [definedInLength];
3321 if (!S.empty())
3322 std::memcpy(this->definedIn, S.data(), definedInLength);
3323 }
3324
3325 bool getGeneratedDeclaration() const {
3326 return generatedDeclaration;
3327 }
3328
3329
3330
3331 static bool classof(const Attr *A) { return A->getKind() == attr::ExternalSourceSymbol; }
3332};
3333
3334class FallThroughAttr : public StmtAttr {
3335public:
3336 static FallThroughAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3337 auto *A = new (Ctx) FallThroughAttr(Loc, Ctx, 0);
3338 A->setImplicit(true);
3339 return A;
3340 }
3341
3342 FallThroughAttr(SourceRange R, ASTContext &Ctx
3343 , unsigned SI
3344 )
3345 : StmtAttr(attr::FallThrough, R, SI, false)
3346 {
3347 }
3348
3349 FallThroughAttr *clone(ASTContext &C) const;
3350 void printPretty(raw_ostream &OS,
3351 const PrintingPolicy &Policy) const;
3352 const char *getSpelling() const;
3353
3354
3355 static bool classof(const Attr *A) { return A->getKind() == attr::FallThrough; }
3356};
3357
3358class FastCallAttr : public InheritableAttr {
3359public:
3360 static FastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3361 auto *A = new (Ctx) FastCallAttr(Loc, Ctx, 0);
3362 A->setImplicit(true);
3363 return A;
3364 }
3365
3366 FastCallAttr(SourceRange R, ASTContext &Ctx
3367 , unsigned SI
3368 )
3369 : InheritableAttr(attr::FastCall, R, SI, false, false)
3370 {
3371 }
3372
3373 FastCallAttr *clone(ASTContext &C) const;
3374 void printPretty(raw_ostream &OS,
3375 const PrintingPolicy &Policy) const;
3376 const char *getSpelling() const;
3377
3378
3379 static bool classof(const Attr *A) { return A->getKind() == attr::FastCall; }
3380};
3381
3382class FinalAttr : public InheritableAttr {
3383public:
3384 enum Spelling {
3385 Keyword_final = 0,
3386 Keyword_sealed = 1
3387 };
3388
3389 static FinalAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
3390 auto *A = new (Ctx) FinalAttr(Loc, Ctx, S);
3391 A->setImplicit(true);
3392 return A;
3393 }
3394
3395 FinalAttr(SourceRange R, ASTContext &Ctx
3396 , unsigned SI
3397 )
3398 : InheritableAttr(attr::Final, R, SI, false, false)
3399 {
3400 }
3401
3402 FinalAttr *clone(ASTContext &C) const;
3403 void printPretty(raw_ostream &OS,
3404 const PrintingPolicy &Policy) const;
3405 const char *getSpelling() const;
3406 Spelling getSemanticSpelling() const {
3407 switch (SpellingListIndex) {
3408 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3408)
;
3409 case 0: return Keyword_final;
3410 case 1: return Keyword_sealed;
3411 }
3412 }
3413 bool isSpelledAsSealed() const { return SpellingListIndex == 1; }
3414
3415
3416 static bool classof(const Attr *A) { return A->getKind() == attr::Final; }
3417};
3418
3419class FlagEnumAttr : public InheritableAttr {
3420public:
3421 static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3422 auto *A = new (Ctx) FlagEnumAttr(Loc, Ctx, 0);
3423 A->setImplicit(true);
3424 return A;
3425 }
3426
3427 FlagEnumAttr(SourceRange R, ASTContext &Ctx
3428 , unsigned SI
3429 )
3430 : InheritableAttr(attr::FlagEnum, R, SI, false, false)
3431 {
3432 }
3433
3434 FlagEnumAttr *clone(ASTContext &C) const;
3435 void printPretty(raw_ostream &OS,
3436 const PrintingPolicy &Policy) const;
3437 const char *getSpelling() const;
3438
3439
3440 static bool classof(const Attr *A) { return A->getKind() == attr::FlagEnum; }
3441};
3442
3443class FlattenAttr : public InheritableAttr {
3444public:
3445 static FlattenAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3446 auto *A = new (Ctx) FlattenAttr(Loc, Ctx, 0);
3447 A->setImplicit(true);
3448 return A;
3449 }
3450
3451 FlattenAttr(SourceRange R, ASTContext &Ctx
3452 , unsigned SI
3453 )
3454 : InheritableAttr(attr::Flatten, R, SI, false, false)
3455 {
3456 }
3457
3458 FlattenAttr *clone(ASTContext &C) const;
3459 void printPretty(raw_ostream &OS,
3460 const PrintingPolicy &Policy) const;
3461 const char *getSpelling() const;
3462
3463
3464 static bool classof(const Attr *A) { return A->getKind() == attr::Flatten; }
3465};
3466
3467class FormatAttr : public InheritableAttr {
3468IdentifierInfo * type;
3469
3470int formatIdx;
3471
3472int firstArg;
3473
3474public:
3475 static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Loc = SourceRange()) {
3476 auto *A = new (Ctx) FormatAttr(Loc, Ctx, Type, FormatIdx, FirstArg, 0);
3477 A->setImplicit(true);
3478 return A;
3479 }
3480
3481 FormatAttr(SourceRange R, ASTContext &Ctx
3482 , IdentifierInfo * Type
3483 , int FormatIdx
3484 , int FirstArg
3485 , unsigned SI
3486 )
3487 : InheritableAttr(attr::Format, R, SI, false, false)
3488 , type(Type)
3489 , formatIdx(FormatIdx)
3490 , firstArg(FirstArg)
3491 {
3492 }
3493
3494 FormatAttr *clone(ASTContext &C) const;
3495 void printPretty(raw_ostream &OS,
3496 const PrintingPolicy &Policy) const;
3497 const char *getSpelling() const;
3498 IdentifierInfo * getType() const {
3499 return type;
3500 }
3501
3502 int getFormatIdx() const {
3503 return formatIdx;
3504 }
3505
3506 int getFirstArg() const {
3507 return firstArg;
3508 }
3509
3510
3511
3512 static bool classof(const Attr *A) { return A->getKind() == attr::Format; }
3513};
3514
3515class FormatArgAttr : public InheritableAttr {
3516ParamIdx formatIdx;
3517
3518public:
3519 static FormatArgAttr *CreateImplicit(ASTContext &Ctx, ParamIdx FormatIdx, SourceRange Loc = SourceRange()) {
3520 auto *A = new (Ctx) FormatArgAttr(Loc, Ctx, FormatIdx, 0);
3521 A->setImplicit(true);
3522 return A;
3523 }
3524
3525 FormatArgAttr(SourceRange R, ASTContext &Ctx
3526 , ParamIdx FormatIdx
3527 , unsigned SI
3528 )
3529 : InheritableAttr(attr::FormatArg, R, SI, false, false)
3530 , formatIdx(FormatIdx)
3531 {
3532 }
3533
3534 FormatArgAttr *clone(ASTContext &C) const;
3535 void printPretty(raw_ostream &OS,
3536 const PrintingPolicy &Policy) const;
3537 const char *getSpelling() const;
3538 ParamIdx getFormatIdx() const {
3539 return formatIdx;
3540 }
3541
3542
3543
3544 static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; }
3545};
3546
3547class GNUInlineAttr : public InheritableAttr {
3548public:
3549 static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3550 auto *A = new (Ctx) GNUInlineAttr(Loc, Ctx, 0);
3551 A->setImplicit(true);
3552 return A;
3553 }
3554
3555 GNUInlineAttr(SourceRange R, ASTContext &Ctx
3556 , unsigned SI
3557 )
3558 : InheritableAttr(attr::GNUInline, R, SI, false, false)
3559 {
3560 }
3561
3562 GNUInlineAttr *clone(ASTContext &C) const;
3563 void printPretty(raw_ostream &OS,
3564 const PrintingPolicy &Policy) const;
3565 const char *getSpelling() const;
3566
3567
3568 static bool classof(const Attr *A) { return A->getKind() == attr::GNUInline; }
3569};
3570
3571class GuardedByAttr : public InheritableAttr {
3572Expr * arg;
3573
3574public:
3575 static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
3576 auto *A = new (Ctx) GuardedByAttr(Loc, Ctx, Arg, 0);
3577 A->setImplicit(true);
3578 return A;
3579 }
3580
3581 GuardedByAttr(SourceRange R, ASTContext &Ctx
3582 , Expr * Arg
3583 , unsigned SI
3584 )
3585 : InheritableAttr(attr::GuardedBy, R, SI, true, true)
3586 , arg(Arg)
3587 {
3588 }
3589
3590 GuardedByAttr *clone(ASTContext &C) const;
3591 void printPretty(raw_ostream &OS,
3592 const PrintingPolicy &Policy) const;
3593 const char *getSpelling() const;
3594 Expr * getArg() const {
3595 return arg;
3596 }
3597
3598
3599
3600 static bool classof(const Attr *A) { return A->getKind() == attr::GuardedBy; }
3601};
3602
3603class GuardedVarAttr : public InheritableAttr {
3604public:
3605 static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3606 auto *A = new (Ctx) GuardedVarAttr(Loc, Ctx, 0);
3607 A->setImplicit(true);
3608 return A;
3609 }
3610
3611 GuardedVarAttr(SourceRange R, ASTContext &Ctx
3612 , unsigned SI
3613 )
3614 : InheritableAttr(attr::GuardedVar, R, SI, false, false)
3615 {
3616 }
3617
3618 GuardedVarAttr *clone(ASTContext &C) const;
3619 void printPretty(raw_ostream &OS,
3620 const PrintingPolicy &Policy) const;
3621 const char *getSpelling() const;
3622
3623
3624 static bool classof(const Attr *A) { return A->getKind() == attr::GuardedVar; }
3625};
3626
3627class HotAttr : public InheritableAttr {
3628public:
3629 static HotAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3630 auto *A = new (Ctx) HotAttr(Loc, Ctx, 0);
3631 A->setImplicit(true);
3632 return A;
3633 }
3634
3635 HotAttr(SourceRange R, ASTContext &Ctx
3636 , unsigned SI
3637 )
3638 : InheritableAttr(attr::Hot, R, SI, false, false)
3639 {
3640 }
3641
3642 HotAttr *clone(ASTContext &C) const;
3643 void printPretty(raw_ostream &OS,
3644 const PrintingPolicy &Policy) const;
3645 const char *getSpelling() const;
3646
3647
3648 static bool classof(const Attr *A) { return A->getKind() == attr::Hot; }
3649};
3650
3651class IBActionAttr : public InheritableAttr {
3652public:
3653 static IBActionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3654 auto *A = new (Ctx) IBActionAttr(Loc, Ctx, 0);
3655 A->setImplicit(true);
3656 return A;
3657 }
3658
3659 IBActionAttr(SourceRange R, ASTContext &Ctx
3660 , unsigned SI
3661 )
3662 : InheritableAttr(attr::IBAction, R, SI, false, false)
3663 {
3664 }
3665
3666 IBActionAttr *clone(ASTContext &C) const;
3667 void printPretty(raw_ostream &OS,
3668 const PrintingPolicy &Policy) const;
3669 const char *getSpelling() const;
3670
3671
3672 static bool classof(const Attr *A) { return A->getKind() == attr::IBAction; }
3673};
3674
3675class IBOutletAttr : public InheritableAttr {
3676public:
3677 static IBOutletAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3678 auto *A = new (Ctx) IBOutletAttr(Loc, Ctx, 0);
3679 A->setImplicit(true);
3680 return A;
3681 }
3682
3683 IBOutletAttr(SourceRange R, ASTContext &Ctx
3684 , unsigned SI
3685 )
3686 : InheritableAttr(attr::IBOutlet, R, SI, false, false)
3687 {
3688 }
3689
3690 IBOutletAttr *clone(ASTContext &C) const;
3691 void printPretty(raw_ostream &OS,
3692 const PrintingPolicy &Policy) const;
3693 const char *getSpelling() const;
3694
3695
3696 static bool classof(const Attr *A) { return A->getKind() == attr::IBOutlet; }
3697};
3698
3699class IBOutletCollectionAttr : public InheritableAttr {
3700TypeSourceInfo * interface_;
3701
3702public:
3703 static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Loc = SourceRange()) {
3704 auto *A = new (Ctx) IBOutletCollectionAttr(Loc, Ctx, Interface, 0);
3705 A->setImplicit(true);
3706 return A;
3707 }
3708
3709 IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
3710 , TypeSourceInfo * Interface
3711 , unsigned SI
3712 )
3713 : InheritableAttr(attr::IBOutletCollection, R, SI, false, false)
3714 , interface_(Interface)
3715 {
3716 }
3717
3718 IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
3719 , unsigned SI
3720 )
3721 : InheritableAttr(attr::IBOutletCollection, R, SI, false, false)
3722 , interface_()
3723 {
3724 }
3725
3726 IBOutletCollectionAttr *clone(ASTContext &C) const;
3727 void printPretty(raw_ostream &OS,
3728 const PrintingPolicy &Policy) const;
3729 const char *getSpelling() const;
3730 QualType getInterface() const {
3731 return interface_->getType();
3732 } TypeSourceInfo * getInterfaceLoc() const {
3733 return interface_;
3734 }
3735
3736
3737
3738 static bool classof(const Attr *A) { return A->getKind() == attr::IBOutletCollection; }
3739};
3740
3741class IFuncAttr : public Attr {
3742unsigned resolverLength;
3743char *resolver;
3744
3745public:
3746 static IFuncAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Resolver, SourceRange Loc = SourceRange()) {
3747 auto *A = new (Ctx) IFuncAttr(Loc, Ctx, Resolver, 0);
3748 A->setImplicit(true);
3749 return A;
3750 }
3751
3752 IFuncAttr(SourceRange R, ASTContext &Ctx
3753 , llvm::StringRef Resolver
3754 , unsigned SI
3755 )
3756 : Attr(attr::IFunc, R, SI, false)
3757 , resolverLength(Resolver.size()),resolver(new (Ctx, 1) char[resolverLength])
3758 {
3759 if (!Resolver.empty())
3760 std::memcpy(resolver, Resolver.data(), resolverLength);
3761 }
3762
3763 IFuncAttr *clone(ASTContext &C) const;
3764 void printPretty(raw_ostream &OS,
3765 const PrintingPolicy &Policy) const;
3766 const char *getSpelling() const;
3767 llvm::StringRef getResolver() const {
3768 return llvm::StringRef(resolver, resolverLength);
3769 }
3770 unsigned getResolverLength() const {
3771 return resolverLength;
3772 }
3773 void setResolver(ASTContext &C, llvm::StringRef S) {
3774 resolverLength = S.size();
3775 this->resolver = new (C, 1) char [resolverLength];
3776 if (!S.empty())
3777 std::memcpy(this->resolver, S.data(), resolverLength);
3778 }
3779
3780
3781
3782 static bool classof(const Attr *A) { return A->getKind() == attr::IFunc; }
3783};
3784
3785class InitPriorityAttr : public InheritableAttr {
3786unsigned priority;
3787
3788public:
3789 static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, SourceRange Loc = SourceRange()) {
3790 auto *A = new (Ctx) InitPriorityAttr(Loc, Ctx, Priority, 0);
3791 A->setImplicit(true);
3792 return A;
3793 }
3794
3795 InitPriorityAttr(SourceRange R, ASTContext &Ctx
3796 , unsigned Priority
3797 , unsigned SI
3798 )
3799 : InheritableAttr(attr::InitPriority, R, SI, false, false)
3800 , priority(Priority)
3801 {
3802 }
3803
3804 InitPriorityAttr *clone(ASTContext &C) const;
3805 void printPretty(raw_ostream &OS,
3806 const PrintingPolicy &Policy) const;
3807 const char *getSpelling() const;
3808 unsigned getPriority() const {
3809 return priority;
3810 }
3811
3812
3813
3814 static bool classof(const Attr *A) { return A->getKind() == attr::InitPriority; }
3815};
3816
3817class InitSegAttr : public Attr {
3818unsigned sectionLength;
3819char *section;
3820
3821public:
3822 static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, SourceRange Loc = SourceRange()) {
3823 auto *A = new (Ctx) InitSegAttr(Loc, Ctx, Section, 0);
3824 A->setImplicit(true);
3825 return A;
3826 }
3827
3828 InitSegAttr(SourceRange R, ASTContext &Ctx
3829 , llvm::StringRef Section
3830 , unsigned SI
3831 )
3832 : Attr(attr::InitSeg, R, SI, false)
3833 , sectionLength(Section.size()),section(new (Ctx, 1) char[sectionLength])
3834 {
3835 if (!Section.empty())
3836 std::memcpy(section, Section.data(), sectionLength);
3837 }
3838
3839 InitSegAttr *clone(ASTContext &C) const;
3840 void printPretty(raw_ostream &OS,
3841 const PrintingPolicy &Policy) const;
3842 const char *getSpelling() const;
3843 llvm::StringRef getSection() const {
3844 return llvm::StringRef(section, sectionLength);
3845 }
3846 unsigned getSectionLength() const {
3847 return sectionLength;
3848 }
3849 void setSection(ASTContext &C, llvm::StringRef S) {
3850 sectionLength = S.size();
3851 this->section = new (C, 1) char [sectionLength];
3852 if (!S.empty())
3853 std::memcpy(this->section, S.data(), sectionLength);
3854 }
3855
3856
3857 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
3858 OS << " (" << getSection() << ')';
3859 }
3860
3861
3862 static bool classof(const Attr *A) { return A->getKind() == attr::InitSeg; }
3863};
3864
3865class IntelOclBiccAttr : public InheritableAttr {
3866public:
3867 static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3868 auto *A = new (Ctx) IntelOclBiccAttr(Loc, Ctx, 0);
3869 A->setImplicit(true);
3870 return A;
3871 }
3872
3873 IntelOclBiccAttr(SourceRange R, ASTContext &Ctx
3874 , unsigned SI
3875 )
3876 : InheritableAttr(attr::IntelOclBicc, R, SI, false, false)
3877 {
3878 }
3879
3880 IntelOclBiccAttr *clone(ASTContext &C) const;
3881 void printPretty(raw_ostream &OS,
3882 const PrintingPolicy &Policy) const;
3883 const char *getSpelling() const;
3884
3885
3886 static bool classof(const Attr *A) { return A->getKind() == attr::IntelOclBicc; }
3887};
3888
3889class InternalLinkageAttr : public InheritableAttr {
3890public:
3891 static InternalLinkageAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3892 auto *A = new (Ctx) InternalLinkageAttr(Loc, Ctx, 0);
3893 A->setImplicit(true);
3894 return A;
3895 }
3896
3897 InternalLinkageAttr(SourceRange R, ASTContext &Ctx
3898 , unsigned SI
3899 )
3900 : InheritableAttr(attr::InternalLinkage, R, SI, false, false)
3901 {
3902 }
3903
3904 InternalLinkageAttr *clone(ASTContext &C) const;
3905 void printPretty(raw_ostream &OS,
3906 const PrintingPolicy &Policy) const;
3907 const char *getSpelling() const;
3908
3909
3910 static bool classof(const Attr *A) { return A->getKind() == attr::InternalLinkage; }
3911};
3912
3913class LTOVisibilityPublicAttr : public InheritableAttr {
3914public:
3915 static LTOVisibilityPublicAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3916 auto *A = new (Ctx) LTOVisibilityPublicAttr(Loc, Ctx, 0);
3917 A->setImplicit(true);
3918 return A;
3919 }
3920
3921 LTOVisibilityPublicAttr(SourceRange R, ASTContext &Ctx
3922 , unsigned SI
3923 )
3924 : InheritableAttr(attr::LTOVisibilityPublic, R, SI, false, false)
3925 {
3926 }
3927
3928 LTOVisibilityPublicAttr *clone(ASTContext &C) const;
3929 void printPretty(raw_ostream &OS,
3930 const PrintingPolicy &Policy) const;
3931 const char *getSpelling() const;
3932
3933
3934 static bool classof(const Attr *A) { return A->getKind() == attr::LTOVisibilityPublic; }
3935};
3936
3937class LayoutVersionAttr : public InheritableAttr {
3938unsigned version;
3939
3940public:
3941 static LayoutVersionAttr *CreateImplicit(ASTContext &Ctx, unsigned Version, SourceRange Loc = SourceRange()) {
3942 auto *A = new (Ctx) LayoutVersionAttr(Loc, Ctx, Version, 0);
3943 A->setImplicit(true);
3944 return A;
3945 }
3946
3947 LayoutVersionAttr(SourceRange R, ASTContext &Ctx
3948 , unsigned Version
3949 , unsigned SI
3950 )
3951 : InheritableAttr(attr::LayoutVersion, R, SI, false, false)
3952 , version(Version)
3953 {
3954 }
3955
3956 LayoutVersionAttr *clone(ASTContext &C) const;
3957 void printPretty(raw_ostream &OS,
3958 const PrintingPolicy &Policy) const;
3959 const char *getSpelling() const;
3960 unsigned getVersion() const {
3961 return version;
3962 }
3963
3964
3965
3966 static bool classof(const Attr *A) { return A->getKind() == attr::LayoutVersion; }
3967};
3968
3969class LifetimeBoundAttr : public InheritableAttr {
3970public:
3971 static LifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3972 auto *A = new (Ctx) LifetimeBoundAttr(Loc, Ctx, 0);
3973 A->setImplicit(true);
3974 return A;
3975 }
3976
3977 LifetimeBoundAttr(SourceRange R, ASTContext &Ctx
3978 , unsigned SI
3979 )
3980 : InheritableAttr(attr::LifetimeBound, R, SI, false, false)
3981 {
3982 }
3983
3984 LifetimeBoundAttr *clone(ASTContext &C) const;
3985 void printPretty(raw_ostream &OS,
3986 const PrintingPolicy &Policy) const;
3987 const char *getSpelling() const;
3988
3989
3990 static bool classof(const Attr *A) { return A->getKind() == attr::LifetimeBound; }
3991};
3992
3993class LockReturnedAttr : public InheritableAttr {
3994Expr * arg;
3995
3996public:
3997 static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
3998 auto *A = new (Ctx) LockReturnedAttr(Loc, Ctx, Arg, 0);
3999 A->setImplicit(true);
4000 return A;
4001 }
4002
4003 LockReturnedAttr(SourceRange R, ASTContext &Ctx
4004 , Expr * Arg
4005 , unsigned SI
4006 )
4007 : InheritableAttr(attr::LockReturned, R, SI, true, false)
4008 , arg(Arg)
4009 {
4010 }
4011
4012 LockReturnedAttr *clone(ASTContext &C) const;
4013 void printPretty(raw_ostream &OS,
4014 const PrintingPolicy &Policy) const;
4015 const char *getSpelling() const;
4016 Expr * getArg() const {
4017 return arg;
4018 }
4019
4020
4021
4022 static bool classof(const Attr *A) { return A->getKind() == attr::LockReturned; }
4023};
4024
4025class LocksExcludedAttr : public InheritableAttr {
4026 unsigned args_Size;
4027 Expr * *args_;
4028
4029public:
4030 static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
4031 auto *A = new (Ctx) LocksExcludedAttr(Loc, Ctx, Args, ArgsSize, 0);
4032 A->setImplicit(true);
4033 return A;
4034 }
4035
4036 LocksExcludedAttr(SourceRange R, ASTContext &Ctx
4037 , Expr * *Args, unsigned ArgsSize
4038 , unsigned SI
4039 )
4040 : InheritableAttr(attr::LocksExcluded, R, SI, true, true)
4041 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
4042 {
4043 std::copy(Args, Args + args_Size, args_);
4044 }
4045
4046 LocksExcludedAttr(SourceRange R, ASTContext &Ctx
4047 , unsigned SI
4048 )
4049 : InheritableAttr(attr::LocksExcluded, R, SI, true, true)
4050 , args_Size(0), args_(nullptr)
4051 {
4052 }
4053
4054 LocksExcludedAttr *clone(ASTContext &C) const;
4055 void printPretty(raw_ostream &OS,
4056 const PrintingPolicy &Policy) const;
4057 const char *getSpelling() const;
4058 typedef Expr ** args_iterator;
4059 args_iterator args_begin() const { return args_; }
4060 args_iterator args_end() const { return args_ + args_Size; }
4061 unsigned args_size() const { return args_Size; }
4062 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
4063
4064
4065
4066
4067 static bool classof(const Attr *A) { return A->getKind() == attr::LocksExcluded; }
4068};
4069
4070class LoopHintAttr : public Attr {
4071public:
4072 enum OptionType {
4073 Vectorize,
4074 VectorizeWidth,
4075 Interleave,
4076 InterleaveCount,
4077 Unroll,
4078 UnrollCount,
4079 UnrollAndJam,
4080 UnrollAndJamCount,
4081 PipelineDisabled,
4082 PipelineInitiationInterval,
4083 Distribute
4084 };
4085private:
4086 OptionType option;
4087
4088public:
4089 enum LoopHintState {
4090 Enable,
4091 Disable,
4092 Numeric,
4093 AssumeSafety,
4094 Full
4095 };
4096private:
4097 LoopHintState state;
4098
4099Expr * value;
4100
4101public:
4102 enum Spelling {
4103 Pragma_clang_loop = 0,
4104 Pragma_unroll = 1,
4105 Pragma_nounroll = 2,
4106 Pragma_unroll_and_jam = 3,
4107 Pragma_nounroll_and_jam = 4
4108 };
4109
4110 static LoopHintAttr *CreateImplicit(ASTContext &Ctx, Spelling S, OptionType Option, LoopHintState State, Expr * Value, SourceRange Loc = SourceRange()) {
4111 auto *A = new (Ctx) LoopHintAttr(Loc, Ctx, Option, State, Value, S);
4112 A->setImplicit(true);
4113 return A;
4114 }
4115
4116 LoopHintAttr(SourceRange R, ASTContext &Ctx
4117 , OptionType Option
4118 , LoopHintState State
4119 , Expr * Value
4120 , unsigned SI
4121 )
4122 : Attr(attr::LoopHint, R, SI, false)
4123 , option(Option)
4124 , state(State)
4125 , value(Value)
4126 {
4127 }
4128
4129 LoopHintAttr *clone(ASTContext &C) const;
4130 void printPretty(raw_ostream &OS,
4131 const PrintingPolicy &Policy) const;
4132 const char *getSpelling() const;
4133 Spelling getSemanticSpelling() const {
4134 switch (SpellingListIndex) {
4135 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4135)
;
4136 case 0: return Pragma_clang_loop;
4137 case 1: return Pragma_unroll;
4138 case 2: return Pragma_nounroll;
4139 case 3: return Pragma_unroll_and_jam;
4140 case 4: return Pragma_nounroll_and_jam;
4141 }
4142 }
4143 OptionType getOption() const {
4144 return option;
4145 }
4146
4147 static bool ConvertStrToOptionType(StringRef Val, OptionType &Out) {
4148 Optional<OptionType> R = llvm::StringSwitch<Optional<OptionType>>(Val)
4149 .Case("vectorize", LoopHintAttr::Vectorize)
4150 .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
4151 .Case("interleave", LoopHintAttr::Interleave)
4152 .Case("interleave_count", LoopHintAttr::InterleaveCount)
4153 .Case("unroll", LoopHintAttr::Unroll)
4154 .Case("unroll_count", LoopHintAttr::UnrollCount)
4155 .Case("unroll_and_jam", LoopHintAttr::UnrollAndJam)
4156 .Case("unroll_and_jam_count", LoopHintAttr::UnrollAndJamCount)
4157 .Case("pipeline", LoopHintAttr::PipelineDisabled)
4158 .Case("pipeline_initiation_interval", LoopHintAttr::PipelineInitiationInterval)
4159 .Case("distribute", LoopHintAttr::Distribute)
4160 .Default(Optional<OptionType>());
4161 if (R) {
4162 Out = *R;
4163 return true;
4164 }
4165 return false;
4166 }
4167
4168 static const char *ConvertOptionTypeToStr(OptionType Val) {
4169 switch(Val) {
4170 case LoopHintAttr::Vectorize: return "vectorize";
4171 case LoopHintAttr::VectorizeWidth: return "vectorize_width";
4172 case LoopHintAttr::Interleave: return "interleave";
4173 case LoopHintAttr::InterleaveCount: return "interleave_count";
4174 case LoopHintAttr::Unroll: return "unroll";
4175 case LoopHintAttr::UnrollCount: return "unroll_count";
4176 case LoopHintAttr::UnrollAndJam: return "unroll_and_jam";
4177 case LoopHintAttr::UnrollAndJamCount: return "unroll_and_jam_count";
4178 case LoopHintAttr::PipelineDisabled: return "pipeline";
4179 case LoopHintAttr::PipelineInitiationInterval: return "pipeline_initiation_interval";
4180 case LoopHintAttr::Distribute: return "distribute";
4181 }
4182 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4182)
;
4183 }
4184 LoopHintState getState() const {
4185 return state;
4186 }
4187
4188 static bool ConvertStrToLoopHintState(StringRef Val, LoopHintState &Out) {
4189 Optional<LoopHintState> R = llvm::StringSwitch<Optional<LoopHintState>>(Val)
4190 .Case("enable", LoopHintAttr::Enable)
4191 .Case("disable", LoopHintAttr::Disable)
4192 .Case("numeric", LoopHintAttr::Numeric)
4193 .Case("assume_safety", LoopHintAttr::AssumeSafety)
4194 .Case("full", LoopHintAttr::Full)
4195 .Default(Optional<LoopHintState>());
4196 if (R) {
4197 Out = *R;
4198 return true;
4199 }
4200 return false;
4201 }
4202
4203 static const char *ConvertLoopHintStateToStr(LoopHintState Val) {
4204 switch(Val) {
4205 case LoopHintAttr::Enable: return "enable";
4206 case LoopHintAttr::Disable: return "disable";
4207 case LoopHintAttr::Numeric: return "numeric";
4208 case LoopHintAttr::AssumeSafety: return "assume_safety";
4209 case LoopHintAttr::Full: return "full";
4210 }
4211 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4211)
;
4212 }
4213 Expr * getValue() const {
4214 return value;
4215 }
4216
4217
4218 static const char *getOptionName(int Option) {
4219 switch(Option) {
4220 case Vectorize: return "vectorize";
4221 case VectorizeWidth: return "vectorize_width";
4222 case Interleave: return "interleave";
4223 case InterleaveCount: return "interleave_count";
4224 case Unroll: return "unroll";
4225 case UnrollCount: return "unroll_count";
4226 case UnrollAndJam: return "unroll_and_jam";
4227 case UnrollAndJamCount: return "unroll_and_jam_count";
4228 case PipelineDisabled: return "pipeline";
4229 case PipelineInitiationInterval: return "pipeline_initiation_interval";
4230 case Distribute: return "distribute";
4231 }
4232 llvm_unreachable("Unhandled LoopHint option.")::llvm::llvm_unreachable_internal("Unhandled LoopHint option."
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4232)
;
4233 }
4234
4235 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
4236 unsigned SpellingIndex = getSpellingListIndex();
4237 // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
4238 // "nounroll" is already emitted as the pragma name.
4239 if (SpellingIndex == Pragma_nounroll || SpellingIndex == Pragma_nounroll_and_jam)
4240 return;
4241 else if (SpellingIndex == Pragma_unroll || SpellingIndex == Pragma_unroll_and_jam) {
4242 OS << ' ' << getValueString(Policy);
4243 return;
4244 }
4245
4246 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")((SpellingIndex == Pragma_clang_loop && "Unexpected spelling"
) ? static_cast<void> (0) : __assert_fail ("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4246, __PRETTY_FUNCTION__))
;
4247 OS << ' ' << getOptionName(option) << getValueString(Policy);
4248 }
4249
4250 // Return a string containing the loop hint argument including the
4251 // enclosing parentheses.
4252 std::string getValueString(const PrintingPolicy &Policy) const {
4253 std::string ValueName;
4254 llvm::raw_string_ostream OS(ValueName);
4255 OS << "(";
4256 if (state == Numeric)
4257 value->printPretty(OS, nullptr, Policy);
4258 else if (state == Enable)
4259 OS << "enable";
4260 else if (state == Full)
4261 OS << "full";
4262 else if (state == AssumeSafety)
4263 OS << "assume_safety";
4264 else
4265 OS << "disable";
4266 OS << ")";
4267 return OS.str();
4268 }
4269
4270 // Return a string suitable for identifying this attribute in diagnostics.
4271 std::string getDiagnosticName(const PrintingPolicy &Policy) const {
4272 unsigned SpellingIndex = getSpellingListIndex();
4273 if (SpellingIndex == Pragma_nounroll)
4274 return "#pragma nounroll";
4275 else if (SpellingIndex == Pragma_unroll)
4276 return "#pragma unroll" + (option == UnrollCount ? getValueString(Policy) : "");
4277 else if (SpellingIndex == Pragma_nounroll_and_jam)
4278 return "#pragma nounroll_and_jam";
4279 else if (SpellingIndex == Pragma_unroll_and_jam)
4280 return "#pragma unroll_and_jam" +
4281 (option == UnrollAndJamCount ? getValueString(Policy) : "");
4282
4283 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")((SpellingIndex == Pragma_clang_loop && "Unexpected spelling"
) ? static_cast<void> (0) : __assert_fail ("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4283, __PRETTY_FUNCTION__))
;
4284 return getOptionName(option) + getValueString(Policy);
4285 }
4286
4287
4288 static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; }
4289};
4290
4291class MIGServerRoutineAttr : public InheritableAttr {
4292public:
4293 static MIGServerRoutineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4294 auto *A = new (Ctx) MIGServerRoutineAttr(Loc, Ctx, 0);
4295 A->setImplicit(true);
4296 return A;
4297 }
4298
4299 MIGServerRoutineAttr(SourceRange R, ASTContext &Ctx
4300 , unsigned SI
4301 )
4302 : InheritableAttr(attr::MIGServerRoutine, R, SI, false, false)
4303 {
4304 }
4305
4306 MIGServerRoutineAttr *clone(ASTContext &C) const;
4307 void printPretty(raw_ostream &OS,
4308 const PrintingPolicy &Policy) const;
4309 const char *getSpelling() const;
4310
4311
4312 static bool classof(const Attr *A) { return A->getKind() == attr::MIGServerRoutine; }
4313};
4314
4315class MSABIAttr : public InheritableAttr {
4316public:
4317 static MSABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4318 auto *A = new (Ctx) MSABIAttr(Loc, Ctx, 0);
4319 A->setImplicit(true);
4320 return A;
4321 }
4322
4323 MSABIAttr(SourceRange R, ASTContext &Ctx
4324 , unsigned SI
4325 )
4326 : InheritableAttr(attr::MSABI, R, SI, false, false)
4327 {
4328 }
4329
4330 MSABIAttr *clone(ASTContext &C) const;
4331 void printPretty(raw_ostream &OS,
4332 const PrintingPolicy &Policy) const;
4333 const char *getSpelling() const;
4334
4335
4336 static bool classof(const Attr *A) { return A->getKind() == attr::MSABI; }
4337};
4338
4339class MSAllocatorAttr : public InheritableAttr {
4340public:
4341 static MSAllocatorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4342 auto *A = new (Ctx) MSAllocatorAttr(Loc, Ctx, 0);
4343 A->setImplicit(true);
4344 return A;
4345 }
4346
4347 MSAllocatorAttr(SourceRange R, ASTContext &Ctx
4348 , unsigned SI
4349 )
4350 : InheritableAttr(attr::MSAllocator, R, SI, false, false)
4351 {
4352 }
4353
4354 MSAllocatorAttr *clone(ASTContext &C) const;
4355 void printPretty(raw_ostream &OS,
4356 const PrintingPolicy &Policy) const;
4357 const char *getSpelling() const;
4358
4359
4360 static bool classof(const Attr *A) { return A->getKind() == attr::MSAllocator; }
4361};
4362
4363class MSInheritanceAttr : public InheritableAttr {
4364bool bestCase;
4365
4366public:
4367 enum Spelling {
4368 Keyword_single_inheritance = 0,
4369 Keyword_multiple_inheritance = 1,
4370 Keyword_virtual_inheritance = 2,
4371 Keyword_unspecified_inheritance = 3
4372 };
4373
4374 static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool BestCase, SourceRange Loc = SourceRange()) {
4375 auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, BestCase, S);
4376 A->setImplicit(true);
4377 return A;
4378 }
4379
4380 static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4381 auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, S);
4382 A->setImplicit(true);
4383 return A;
4384 }
4385
4386 MSInheritanceAttr(SourceRange R, ASTContext &Ctx
4387 , bool BestCase
4388 , unsigned SI
4389 )
4390 : InheritableAttr(attr::MSInheritance, R, SI, false, false)
4391 , bestCase(BestCase)
4392 {
4393 }
4394
4395 MSInheritanceAttr(SourceRange R, ASTContext &Ctx
4396 , unsigned SI
4397 )
4398 : InheritableAttr(attr::MSInheritance, R, SI, false, false)
4399 , bestCase()
4400 {
4401 }
4402
4403 MSInheritanceAttr *clone(ASTContext &C) const;
4404 void printPretty(raw_ostream &OS,
4405 const PrintingPolicy &Policy) const;
4406 const char *getSpelling() const;
4407 Spelling getSemanticSpelling() const {
4408 switch (SpellingListIndex) {
4409 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4409)
;
4410 case 0: return Keyword_single_inheritance;
4411 case 1: return Keyword_multiple_inheritance;
4412 case 2: return Keyword_virtual_inheritance;
4413 case 3: return Keyword_unspecified_inheritance;
4414 }
4415 }
4416 bool getBestCase() const {
4417 return bestCase;
4418 }
4419
4420 static const bool DefaultBestCase = true;
4421
4422
4423 static bool hasVBPtrOffsetField(Spelling Inheritance) {
4424 return Inheritance == Keyword_unspecified_inheritance;
4425 }
4426
4427 // Only member pointers to functions need a this adjustment, since it can be
4428 // combined with the field offset for data pointers.
4429 static bool hasNVOffsetField(bool IsMemberFunction, Spelling Inheritance) {
4430 return IsMemberFunction && Inheritance >= Keyword_multiple_inheritance;
4431 }
4432
4433 static bool hasVBTableOffsetField(Spelling Inheritance) {
4434 return Inheritance >= Keyword_virtual_inheritance;
4435 }
4436
4437 static bool hasOnlyOneField(bool IsMemberFunction,
4438 Spelling Inheritance) {
4439 if (IsMemberFunction)
4440 return Inheritance <= Keyword_single_inheritance;
4441 return Inheritance <= Keyword_multiple_inheritance;
4442 }
4443
4444
4445 static bool classof(const Attr *A) { return A->getKind() == attr::MSInheritance; }
4446};
4447
4448class MSNoVTableAttr : public InheritableAttr {
4449public:
4450 static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4451 auto *A = new (Ctx) MSNoVTableAttr(Loc, Ctx, 0);
4452 A->setImplicit(true);
4453 return A;
4454 }
4455
4456 MSNoVTableAttr(SourceRange R, ASTContext &Ctx
4457 , unsigned SI
4458 )
4459 : InheritableAttr(attr::MSNoVTable, R, SI, false, false)
4460 {
4461 }
4462
4463 MSNoVTableAttr *clone(ASTContext &C) const;
4464 void printPretty(raw_ostream &OS,
4465 const PrintingPolicy &Policy) const;
4466 const char *getSpelling() const;
4467
4468
4469 static bool classof(const Attr *A) { return A->getKind() == attr::MSNoVTable; }
4470};
4471
4472class MSP430InterruptAttr : public InheritableAttr {
4473unsigned number;
4474
4475public:
4476 static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Loc = SourceRange()) {
4477 auto *A = new (Ctx) MSP430InterruptAttr(Loc, Ctx, Number, 0);
4478 A->setImplicit(true);
4479 return A;
4480 }
4481
4482 MSP430InterruptAttr(SourceRange R, ASTContext &Ctx
4483 , unsigned Number
4484 , unsigned SI
4485 )
4486 : InheritableAttr(attr::MSP430Interrupt, R, SI, false, false)
4487 , number(Number)
4488 {
4489 }
4490
4491 MSP430InterruptAttr *clone(ASTContext &C) const;
4492 void printPretty(raw_ostream &OS,
4493 const PrintingPolicy &Policy) const;
4494 const char *getSpelling() const;
4495 unsigned getNumber() const {
4496 return number;
4497 }
4498
4499
4500
4501 static bool classof(const Attr *A) { return A->getKind() == attr::MSP430Interrupt; }
4502};
4503
4504class MSStructAttr : public InheritableAttr {
4505public:
4506 static MSStructAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4507 auto *A = new (Ctx) MSStructAttr(Loc, Ctx, 0);
4508 A->setImplicit(true);
4509 return A;
4510 }
4511
4512 MSStructAttr(SourceRange R, ASTContext &Ctx
4513 , unsigned SI
4514 )
4515 : InheritableAttr(attr::MSStruct, R, SI, false, false)
4516 {
4517 }
4518
4519 MSStructAttr *clone(ASTContext &C) const;
4520 void printPretty(raw_ostream &OS,
4521 const PrintingPolicy &Policy) const;
4522 const char *getSpelling() const;
4523
4524
4525 static bool classof(const Attr *A) { return A->getKind() == attr::MSStruct; }
4526};
4527
4528class MSVtorDispAttr : public InheritableAttr {
4529unsigned vdm;
4530
4531public:
4532 static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, SourceRange Loc = SourceRange()) {
4533 auto *A = new (Ctx) MSVtorDispAttr(Loc, Ctx, Vdm, 0);
4534 A->setImplicit(true);
4535 return A;
4536 }
4537
4538 MSVtorDispAttr(SourceRange R, ASTContext &Ctx
4539 , unsigned Vdm
4540 , unsigned SI
4541 )
4542 : InheritableAttr(attr::MSVtorDisp, R, SI, false, false)
4543 , vdm(Vdm)
4544 {
4545 }
4546
4547 MSVtorDispAttr *clone(ASTContext &C) const;
4548 void printPretty(raw_ostream &OS,
4549 const PrintingPolicy &Policy) const;
4550 const char *getSpelling() const;
4551 unsigned getVdm() const {
4552 return vdm;
4553 }
4554
4555
4556 enum Mode {
4557 Never,
4558 ForVBaseOverride,
4559 ForVFTable
4560 };
4561
4562 Mode getVtorDispMode() const { return Mode(vdm); }
4563
4564
4565 static bool classof(const Attr *A) { return A->getKind() == attr::MSVtorDisp; }
4566};
4567
4568class MaxFieldAlignmentAttr : public InheritableAttr {
4569unsigned alignment;
4570
4571public:
4572 static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Loc = SourceRange()) {
4573 auto *A = new (Ctx) MaxFieldAlignmentAttr(Loc, Ctx, Alignment, 0);
4574 A->setImplicit(true);
4575 return A;
4576 }
4577
4578 MaxFieldAlignmentAttr(SourceRange R, ASTContext &Ctx
4579 , unsigned Alignment
4580 , unsigned SI
4581 )
4582 : InheritableAttr(attr::MaxFieldAlignment, R, SI, false, false)
4583 , alignment(Alignment)
4584 {
4585 }
4586
4587 MaxFieldAlignmentAttr *clone(ASTContext &C) const;
4588 void printPretty(raw_ostream &OS,
4589 const PrintingPolicy &Policy) const;
4590 const char *getSpelling() const;
4591 unsigned getAlignment() const {
4592 return alignment;
4593 }
4594
4595
4596
4597 static bool classof(const Attr *A) { return A->getKind() == attr::MaxFieldAlignment; }
4598};
4599
4600class MayAliasAttr : public InheritableAttr {
4601public:
4602 static MayAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4603 auto *A = new (Ctx) MayAliasAttr(Loc, Ctx, 0);
4604 A->setImplicit(true);
4605 return A;
4606 }
4607
4608 MayAliasAttr(SourceRange R, ASTContext &Ctx
4609 , unsigned SI
4610 )
4611 : InheritableAttr(attr::MayAlias, R, SI, false, false)
4612 {
4613 }
4614
4615 MayAliasAttr *clone(ASTContext &C) const;
4616 void printPretty(raw_ostream &OS,
4617 const PrintingPolicy &Policy) const;
4618 const char *getSpelling() const;
4619
4620
4621 static bool classof(const Attr *A) { return A->getKind() == attr::MayAlias; }
4622};
4623
4624class MicroMipsAttr : public InheritableAttr {
4625public:
4626 static MicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4627 auto *A = new (Ctx) MicroMipsAttr(Loc, Ctx, 0);
4628 A->setImplicit(true);
4629 return A;
4630 }
4631
4632 MicroMipsAttr(SourceRange R, ASTContext &Ctx
4633 , unsigned SI
4634 )
4635 : InheritableAttr(attr::MicroMips, R, SI, false, false)
4636 {
4637 }
4638
4639 MicroMipsAttr *clone(ASTContext &C) const;
4640 void printPretty(raw_ostream &OS,
4641 const PrintingPolicy &Policy) const;
4642 const char *getSpelling() const;
4643
4644
4645 static bool classof(const Attr *A) { return A->getKind() == attr::MicroMips; }
4646};
4647
4648class MinSizeAttr : public InheritableAttr {
4649public:
4650 static MinSizeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4651 auto *A = new (Ctx) MinSizeAttr(Loc, Ctx, 0);
4652 A->setImplicit(true);
4653 return A;
4654 }
4655
4656 MinSizeAttr(SourceRange R, ASTContext &Ctx
4657 , unsigned SI
4658 )
4659 : InheritableAttr(attr::MinSize, R, SI, false, false)
4660 {
4661 }
4662
4663 MinSizeAttr *clone(ASTContext &C) const;
4664 void printPretty(raw_ostream &OS,
4665 const PrintingPolicy &Policy) const;
4666 const char *getSpelling() const;
4667
4668
4669 static bool classof(const Attr *A) { return A->getKind() == attr::MinSize; }
4670};
4671
4672class MinVectorWidthAttr : public InheritableAttr {
4673unsigned vectorWidth;
4674
4675public:
4676 static MinVectorWidthAttr *CreateImplicit(ASTContext &Ctx, unsigned VectorWidth, SourceRange Loc = SourceRange()) {
4677 auto *A = new (Ctx) MinVectorWidthAttr(Loc, Ctx, VectorWidth, 0);
4678 A->setImplicit(true);
4679 return A;
4680 }
4681
4682 MinVectorWidthAttr(SourceRange R, ASTContext &Ctx
4683 , unsigned VectorWidth
4684 , unsigned SI
4685 )
4686 : InheritableAttr(attr::MinVectorWidth, R, SI, false, false)
4687 , vectorWidth(VectorWidth)
4688 {
4689 }
4690
4691 MinVectorWidthAttr *clone(ASTContext &C) const;
4692 void printPretty(raw_ostream &OS,
4693 const PrintingPolicy &Policy) const;
4694 const char *getSpelling() const;
4695 unsigned getVectorWidth() const {
4696 return vectorWidth;
4697 }
4698
4699
4700
4701 static bool classof(const Attr *A) { return A->getKind() == attr::MinVectorWidth; }
4702};
4703
4704class Mips16Attr : public InheritableAttr {
4705public:
4706 static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4707 auto *A = new (Ctx) Mips16Attr(Loc, Ctx, 0);
4708 A->setImplicit(true);
4709 return A;
4710 }
4711
4712 Mips16Attr(SourceRange R, ASTContext &Ctx
4713 , unsigned SI
4714 )
4715 : InheritableAttr(attr::Mips16, R, SI, false, false)
4716 {
4717 }
4718
4719 Mips16Attr *clone(ASTContext &C) const;
4720 void printPretty(raw_ostream &OS,
4721 const PrintingPolicy &Policy) const;
4722 const char *getSpelling() const;
4723
4724
4725 static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; }
4726};
4727
4728class MipsInterruptAttr : public InheritableAttr {
4729public:
4730 enum InterruptType {
4731 sw0,
4732 sw1,
4733 hw0,
4734 hw1,
4735 hw2,
4736 hw3,
4737 hw4,
4738 hw5,
4739 eic
4740 };
4741private:
4742 InterruptType interrupt;
4743
4744public:
4745 static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
4746 auto *A = new (Ctx) MipsInterruptAttr(Loc, Ctx, Interrupt, 0);
4747 A->setImplicit(true);
4748 return A;
4749 }
4750
4751 MipsInterruptAttr(SourceRange R, ASTContext &Ctx
4752 , InterruptType Interrupt
4753 , unsigned SI
4754 )
4755 : InheritableAttr(attr::MipsInterrupt, R, SI, false, false)
4756 , interrupt(Interrupt)
4757 {
4758 }
4759
4760 MipsInterruptAttr *clone(ASTContext &C) const;
4761 void printPretty(raw_ostream &OS,
4762 const PrintingPolicy &Policy) const;
4763 const char *getSpelling() const;
4764 InterruptType getInterrupt() const {
4765 return interrupt;
4766 }
4767
4768 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
4769 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
4770 .Case("vector=sw0", MipsInterruptAttr::sw0)
4771 .Case("vector=sw1", MipsInterruptAttr::sw1)
4772 .Case("vector=hw0", MipsInterruptAttr::hw0)
4773 .Case("vector=hw1", MipsInterruptAttr::hw1)
4774 .Case("vector=hw2", MipsInterruptAttr::hw2)
4775 .Case("vector=hw3", MipsInterruptAttr::hw3)
4776 .Case("vector=hw4", MipsInterruptAttr::hw4)
4777 .Case("vector=hw5", MipsInterruptAttr::hw5)
4778 .Case("eic", MipsInterruptAttr::eic)
4779 .Case("", MipsInterruptAttr::eic)
4780 .Default(Optional<InterruptType>());
4781 if (R) {
4782 Out = *R;
4783 return true;
4784 }
4785 return false;
4786 }
4787
4788 static const char *ConvertInterruptTypeToStr(InterruptType Val) {
4789 switch(Val) {
4790 case MipsInterruptAttr::sw0: return "vector=sw0";
4791 case MipsInterruptAttr::sw1: return "vector=sw1";
4792 case MipsInterruptAttr::hw0: return "vector=hw0";
4793 case MipsInterruptAttr::hw1: return "vector=hw1";
4794 case MipsInterruptAttr::hw2: return "vector=hw2";
4795 case MipsInterruptAttr::hw3: return "vector=hw3";
4796 case MipsInterruptAttr::hw4: return "vector=hw4";
4797 case MipsInterruptAttr::hw5: return "vector=hw5";
4798 case MipsInterruptAttr::eic: return "eic";
4799 }
4800 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4800)
;
4801 }
4802
4803
4804 static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; }
4805};
4806
4807class MipsLongCallAttr : public InheritableAttr {
4808public:
4809 enum Spelling {
4810 GNU_long_call = 0,
4811 CXX11_gnu_long_call = 1,
4812 GNU_far = 2,
4813 CXX11_gnu_far = 3
4814 };
4815
4816 static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4817 auto *A = new (Ctx) MipsLongCallAttr(Loc, Ctx, S);
4818 A->setImplicit(true);
4819 return A;
4820 }
4821
4822 MipsLongCallAttr(SourceRange R, ASTContext &Ctx
4823 , unsigned SI
4824 )
4825 : InheritableAttr(attr::MipsLongCall, R, SI, false, false)
4826 {
4827 }
4828
4829 MipsLongCallAttr *clone(ASTContext &C) const;
4830 void printPretty(raw_ostream &OS,
4831 const PrintingPolicy &Policy) const;
4832 const char *getSpelling() const;
4833 Spelling getSemanticSpelling() const {
4834 switch (SpellingListIndex) {
4835 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4835)
;
4836 case 0: return GNU_long_call;
4837 case 1: return CXX11_gnu_long_call;
4838 case 2: return GNU_far;
4839 case 3: return CXX11_gnu_far;
4840 }
4841 }
4842
4843
4844 static bool classof(const Attr *A) { return A->getKind() == attr::MipsLongCall; }
4845};
4846
4847class MipsShortCallAttr : public InheritableAttr {
4848public:
4849 enum Spelling {
4850 GNU_short_call = 0,
4851 CXX11_gnu_short_call = 1,
4852 GNU_near = 2,
4853 CXX11_gnu_near = 3
4854 };
4855
4856 static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4857 auto *A = new (Ctx) MipsShortCallAttr(Loc, Ctx, S);
4858 A->setImplicit(true);
4859 return A;
4860 }
4861
4862 MipsShortCallAttr(SourceRange R, ASTContext &Ctx
4863 , unsigned SI
4864 )
4865 : InheritableAttr(attr::MipsShortCall, R, SI, false, false)
4866 {
4867 }
4868
4869 MipsShortCallAttr *clone(ASTContext &C) const;
4870 void printPretty(raw_ostream &OS,
4871 const PrintingPolicy &Policy) const;
4872 const char *getSpelling() const;
4873 Spelling getSemanticSpelling() const {
4874 switch (SpellingListIndex) {
4875 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4875)
;
4876 case 0: return GNU_short_call;
4877 case 1: return CXX11_gnu_short_call;
4878 case 2: return GNU_near;
4879 case 3: return CXX11_gnu_near;
4880 }
4881 }
4882
4883
4884 static bool classof(const Attr *A) { return A->getKind() == attr::MipsShortCall; }
4885};
4886
4887class ModeAttr : public Attr {
4888IdentifierInfo * mode;
4889
4890public:
4891 static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Loc = SourceRange()) {
4892 auto *A = new (Ctx) ModeAttr(Loc, Ctx, Mode, 0);
4893 A->setImplicit(true);
4894 return A;
4895 }
4896
4897 ModeAttr(SourceRange R, ASTContext &Ctx
4898 , IdentifierInfo * Mode
4899 , unsigned SI
4900 )
4901 : Attr(attr::Mode, R, SI, false)
4902 , mode(Mode)
4903 {
4904 }
4905
4906 ModeAttr *clone(ASTContext &C) const;
4907 void printPretty(raw_ostream &OS,
4908 const PrintingPolicy &Policy) const;
4909 const char *getSpelling() const;
4910 IdentifierInfo * getMode() const {
4911 return mode;
4912 }
4913
4914
4915
4916 static bool classof(const Attr *A) { return A->getKind() == attr::Mode; }
4917};
4918
4919class NSConsumedAttr : public InheritableParamAttr {
4920public:
4921 static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4922 auto *A = new (Ctx) NSConsumedAttr(Loc, Ctx, 0);
4923 A->setImplicit(true);
4924 return A;
4925 }
4926
4927 NSConsumedAttr(SourceRange R, ASTContext &Ctx
4928 , unsigned SI
4929 )
4930 : InheritableParamAttr(attr::NSConsumed, R, SI, false, false)
4931 {
4932 }
4933
4934 NSConsumedAttr *clone(ASTContext &C) const;
4935 void printPretty(raw_ostream &OS,
4936 const PrintingPolicy &Policy) const;
4937 const char *getSpelling() const;
4938
4939
4940 static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; }
4941};
4942
4943class NSConsumesSelfAttr : public InheritableAttr {
4944public:
4945 static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4946 auto *A = new (Ctx) NSConsumesSelfAttr(Loc, Ctx, 0);
4947 A->setImplicit(true);
4948 return A;
4949 }
4950
4951 NSConsumesSelfAttr(SourceRange R, ASTContext &Ctx
4952 , unsigned SI
4953 )
4954 : InheritableAttr(attr::NSConsumesSelf, R, SI, false, false)
4955 {
4956 }
4957
4958 NSConsumesSelfAttr *clone(ASTContext &C) const;
4959 void printPretty(raw_ostream &OS,
4960 const PrintingPolicy &Policy) const;
4961 const char *getSpelling() const;
4962
4963
4964 static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; }
4965};
4966
4967class NSReturnsAutoreleasedAttr : public InheritableAttr {
4968public:
4969 static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4970 auto *A = new (Ctx) NSReturnsAutoreleasedAttr(Loc, Ctx, 0);
4971 A->setImplicit(true);
4972 return A;
4973 }
4974
4975 NSReturnsAutoreleasedAttr(SourceRange R, ASTContext &Ctx
4976 , unsigned SI
4977 )
4978 : InheritableAttr(attr::NSReturnsAutoreleased, R, SI, false, false)
4979 {
4980 }
4981
4982 NSReturnsAutoreleasedAttr *clone(ASTContext &C) const;
4983 void printPretty(raw_ostream &OS,
4984 const PrintingPolicy &Policy) const;
4985 const char *getSpelling() const;
4986
4987
4988 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; }
4989};
4990
4991class NSReturnsNotRetainedAttr : public InheritableAttr {
4992public:
4993 static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4994 auto *A = new (Ctx) NSReturnsNotRetainedAttr(Loc, Ctx, 0);
4995 A->setImplicit(true);
4996 return A;
4997 }
4998
4999 NSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
5000 , unsigned SI
5001 )
5002 : InheritableAttr(attr::NSReturnsNotRetained, R, SI, false, false)
5003 {
5004 }
5005
5006 NSReturnsNotRetainedAttr *clone(ASTContext &C) const;
5007 void printPretty(raw_ostream &OS,
5008 const PrintingPolicy &Policy) const;
5009 const char *getSpelling() const;
5010
5011
5012 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; }
5013};
5014
5015class NSReturnsRetainedAttr : public InheritableAttr {
5016public:
5017 static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5018 auto *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0);
5019 A->setImplicit(true);
5020 return A;
5021 }
5022
5023 NSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
5024 , unsigned SI
5025 )
5026 : InheritableAttr(attr::NSReturnsRetained, R, SI, false, false)
5027 {
5028 }
5029
5030 NSReturnsRetainedAttr *clone(ASTContext &C) const;
5031 void printPretty(raw_ostream &OS,
5032 const PrintingPolicy &Policy) const;
5033 const char *getSpelling() const;
5034
5035
5036 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; }
5037};
5038
5039class NakedAttr : public InheritableAttr {
5040public:
5041 static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5042 auto *A = new (Ctx) NakedAttr(Loc, Ctx, 0);
5043 A->setImplicit(true);
5044 return A;
5045 }
5046
5047 NakedAttr(SourceRange R, ASTContext &Ctx
5048 , unsigned SI
5049 )
5050 : InheritableAttr(attr::Naked, R, SI, false, false)
5051 {
5052 }
5053
5054 NakedAttr *clone(ASTContext &C) const;
5055 void printPretty(raw_ostream &OS,
5056 const PrintingPolicy &Policy) const;
5057 const char *getSpelling() const;
5058
5059
5060 static bool classof(const Attr *A) { return A->getKind() == attr::Naked; }
5061};
5062
5063class NoAliasAttr : public InheritableAttr {
5064public:
5065 static NoAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5066 auto *A = new (Ctx) NoAliasAttr(Loc, Ctx, 0);
5067 A->setImplicit(true);
5068 return A;
5069 }
5070
5071 NoAliasAttr(SourceRange R, ASTContext &Ctx
5072 , unsigned SI
5073 )
5074 : InheritableAttr(attr::NoAlias, R, SI, false, false)
5075 {
5076 }
5077
5078 NoAliasAttr *clone(ASTContext &C) const;
5079 void printPretty(raw_ostream &OS,
5080 const PrintingPolicy &Policy) const;
5081 const char *getSpelling() const;
5082
5083
5084 static bool classof(const Attr *A) { return A->getKind() == attr::NoAlias; }
5085};
5086
5087class NoCommonAttr : public InheritableAttr {
5088public:
5089 static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5090 auto *A = new (Ctx) NoCommonAttr(Loc, Ctx, 0);
5091 A->setImplicit(true);
5092 return A;
5093 }
5094
5095 NoCommonAttr(SourceRange R, ASTContext &Ctx
5096 , unsigned SI
5097 )
5098 : InheritableAttr(attr::NoCommon, R, SI, false, false)
5099 {
5100 }
5101
5102 NoCommonAttr *clone(ASTContext &C) const;
5103 void printPretty(raw_ostream &OS,
5104 const PrintingPolicy &Policy) const;
5105 const char *getSpelling() const;
5106
5107
5108 static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; }
5109};
5110
5111class NoDebugAttr : public InheritableAttr {
5112public:
5113 static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5114 auto *A = new (Ctx) NoDebugAttr(Loc, Ctx, 0);
5115 A->setImplicit(true);
5116 return A;
5117 }
5118
5119 NoDebugAttr(SourceRange R, ASTContext &Ctx
5120 , unsigned SI
5121 )
5122 : InheritableAttr(attr::NoDebug, R, SI, false, false)
5123 {
5124 }
5125
5126 NoDebugAttr *clone(ASTContext &C) const;
5127 void printPretty(raw_ostream &OS,
5128 const PrintingPolicy &Policy) const;
5129 const char *getSpelling() const;
5130
5131
5132 static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; }
5133};
5134
5135class NoDerefAttr : public TypeAttr {
5136public:
5137 static NoDerefAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5138 auto *A = new (Ctx) NoDerefAttr(Loc, Ctx, 0);
5139 A->setImplicit(true);
5140 return A;
5141 }
5142
5143 NoDerefAttr(SourceRange R, ASTContext &Ctx
5144 , unsigned SI
5145 )
5146 : TypeAttr(attr::NoDeref, R, SI, false)
5147 {
5148 }
5149
5150 NoDerefAttr *clone(ASTContext &C) const;
5151 void printPretty(raw_ostream &OS,
5152 const PrintingPolicy &Policy) const;
5153 const char *getSpelling() const;
5154
5155
5156 static bool classof(const Attr *A) { return A->getKind() == attr::NoDeref; }
5157};
5158
5159class NoDestroyAttr : public InheritableAttr {
5160public:
5161 static NoDestroyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5162 auto *A = new (Ctx) NoDestroyAttr(Loc, Ctx, 0);
5163 A->setImplicit(true);
5164 return A;
5165 }
5166
5167 NoDestroyAttr(SourceRange R, ASTContext &Ctx
5168 , unsigned SI
5169 )
5170 : InheritableAttr(attr::NoDestroy, R, SI, false, false)
5171 {
5172 }
5173
5174 NoDestroyAttr *clone(ASTContext &C) const;
5175 void printPretty(raw_ostream &OS,
5176 const PrintingPolicy &Policy) const;
5177 const char *getSpelling() const;
5178
5179
5180 static bool classof(const Attr *A) { return A->getKind() == attr::NoDestroy; }
5181};
5182
5183class NoDuplicateAttr : public InheritableAttr {
5184public:
5185 static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5186 auto *A = new (Ctx) NoDuplicateAttr(Loc, Ctx, 0);
5187 A->setImplicit(true);
5188 return A;
5189 }
5190
5191 NoDuplicateAttr(SourceRange R, ASTContext &Ctx
5192 , unsigned SI
5193 )
5194 : InheritableAttr(attr::NoDuplicate, R, SI, false, false)
5195 {
5196 }
5197
5198 NoDuplicateAttr *clone(ASTContext &C) const;
5199 void printPretty(raw_ostream &OS,
5200 const PrintingPolicy &Policy) const;
5201 const char *getSpelling() const;
5202
5203
5204 static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; }
5205};
5206
5207class NoEscapeAttr : public Attr {
5208public:
5209 static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5210 auto *A = new (Ctx) NoEscapeAttr(Loc, Ctx, 0);
5211 A->setImplicit(true);
5212 return A;
5213 }
5214
5215 NoEscapeAttr(SourceRange R, ASTContext &Ctx
5216 , unsigned SI
5217 )
5218 : Attr(attr::NoEscape, R, SI, false)
5219 {
5220 }
5221
5222 NoEscapeAttr *clone(ASTContext &C) const;
5223 void printPretty(raw_ostream &OS,
5224 const PrintingPolicy &Policy) const;
5225 const char *getSpelling() const;
5226
5227
5228 static bool classof(const Attr *A) { return A->getKind() == attr::NoEscape; }
5229};
5230
5231class NoInlineAttr : public InheritableAttr {
5232public:
5233 static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5234 auto *A = new (Ctx) NoInlineAttr(Loc, Ctx, 0);
5235 A->setImplicit(true);
5236 return A;
5237 }
5238
5239 NoInlineAttr(SourceRange R, ASTContext &Ctx
5240 , unsigned SI
5241 )
5242 : InheritableAttr(attr::NoInline, R, SI, false, false)
5243 {
5244 }
5245
5246 NoInlineAttr *clone(ASTContext &C) const;
5247 void printPretty(raw_ostream &OS,
5248 const PrintingPolicy &Policy) const;
5249 const char *getSpelling() const;
5250
5251
5252 static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; }
5253};
5254
5255class NoInstrumentFunctionAttr : public InheritableAttr {
5256public:
5257 static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5258 auto *A = new (Ctx) NoInstrumentFunctionAttr(Loc, Ctx, 0);
5259 A->setImplicit(true);
5260 return A;
5261 }
5262
5263 NoInstrumentFunctionAttr(SourceRange R, ASTContext &Ctx
5264 , unsigned SI
5265 )
5266 : InheritableAttr(attr::NoInstrumentFunction, R, SI, false, false)
5267 {
5268 }
5269
5270 NoInstrumentFunctionAttr *clone(ASTContext &C) const;
5271 void printPretty(raw_ostream &OS,
5272 const PrintingPolicy &Policy) const;
5273 const char *getSpelling() const;
5274
5275
5276 static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; }
5277};
5278
5279class NoMicroMipsAttr : public InheritableAttr {
5280public:
5281 static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5282 auto *A = new (Ctx) NoMicroMipsAttr(Loc, Ctx, 0);
5283 A->setImplicit(true);
5284 return A;
5285 }
5286
5287 NoMicroMipsAttr(SourceRange R, ASTContext &Ctx
5288 , unsigned SI
5289 )
5290 : InheritableAttr(attr::NoMicroMips, R, SI, false, false)
5291 {
5292 }
5293
5294 NoMicroMipsAttr *clone(ASTContext &C) const;
5295 void printPretty(raw_ostream &OS,
5296 const PrintingPolicy &Policy) const;
5297 const char *getSpelling() const;
5298
5299
5300 static bool classof(const Attr *A) { return A->getKind() == attr::NoMicroMips; }
5301};
5302
5303class NoMips16Attr : public InheritableAttr {
5304public:
5305 static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5306 auto *A = new (Ctx) NoMips16Attr(Loc, Ctx, 0);
5307 A->setImplicit(true);
5308 return A;
5309 }
5310
5311 NoMips16Attr(SourceRange R, ASTContext &Ctx
5312 , unsigned SI
5313 )
5314 : InheritableAttr(attr::NoMips16, R, SI, false, false)
5315 {
5316 }
5317
5318 NoMips16Attr *clone(ASTContext &C) const;
5319 void printPretty(raw_ostream &OS,
5320 const PrintingPolicy &Policy) const;
5321 const char *getSpelling() const;
5322
5323
5324 static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; }
5325};
5326
5327class NoReturnAttr : public InheritableAttr {
5328public:
5329 static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5330 auto *A = new (Ctx) NoReturnAttr(Loc, Ctx, 0);
5331 A->setImplicit(true);
5332 return A;
5333 }
5334
5335 NoReturnAttr(SourceRange R, ASTContext &Ctx
5336 , unsigned SI
5337 )
5338 : InheritableAttr(attr::NoReturn, R, SI, false, false)
5339 {
5340 }
5341
5342 NoReturnAttr *clone(ASTContext &C) const;
5343 void printPretty(raw_ostream &OS,
5344 const PrintingPolicy &Policy) const;
5345 const char *getSpelling() const;
5346
5347
5348 static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; }
5349};
5350
5351class NoSanitizeAttr : public InheritableAttr {
5352 unsigned sanitizers_Size;
5353 StringRef *sanitizers_;
5354
5355public:
5356 static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Loc = SourceRange()) {
5357 auto *A = new (Ctx) NoSanitizeAttr(Loc, Ctx, Sanitizers, SanitizersSize, 0);
5358 A->setImplicit(true);
5359 return A;
5360 }
5361
5362 NoSanitizeAttr(SourceRange R, ASTContext &Ctx
5363 , StringRef *Sanitizers, unsigned SanitizersSize
5364 , unsigned SI
5365 )
5366 : InheritableAttr(attr::NoSanitize, R, SI, false, false)
5367 , sanitizers_Size(SanitizersSize), sanitizers_(new (Ctx, 16) StringRef[sanitizers_Size])
5368 {
5369 for (size_t I = 0, E = sanitizers_Size; I != E;
5370 ++I) {
5371 StringRef Ref = Sanitizers[I];
5372 if (!Ref.empty()) {
5373 char *Mem = new (Ctx, 1) char[Ref.size()];
5374 std::memcpy(Mem, Ref.data(), Ref.size());
5375 sanitizers_[I] = StringRef(Mem, Ref.size());
5376 }
5377 }
5378 }
5379
5380 NoSanitizeAttr(SourceRange R, ASTContext &Ctx
5381 , unsigned SI
5382 )
5383 : InheritableAttr(attr::NoSanitize, R, SI, false, false)
5384 , sanitizers_Size(0), sanitizers_(nullptr)
5385 {
5386 }
5387
5388 NoSanitizeAttr *clone(ASTContext &C) const;
5389 void printPretty(raw_ostream &OS,
5390 const PrintingPolicy &Policy) const;
5391 const char *getSpelling() const;
5392 typedef StringRef* sanitizers_iterator;
5393 sanitizers_iterator sanitizers_begin() const { return sanitizers_; }
5394 sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; }
5395 unsigned sanitizers_size() const { return sanitizers_Size; }
5396 llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); }
5397
5398
5399
5400 SanitizerMask getMask() const {
5401 SanitizerMask Mask;
5402 for (auto SanitizerName : sanitizers()) {
5403 SanitizerMask ParsedMask =
5404 parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
5405 Mask |= expandSanitizerGroups(ParsedMask);
5406 }
5407 return Mask;
5408 }
5409
5410
5411 static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; }
5412};
5413
5414class NoSpeculativeLoadHardeningAttr : public InheritableAttr {
5415public:
5416 static NoSpeculativeLoadHardeningAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5417 auto *A = new (Ctx) NoSpeculativeLoadHardeningAttr(Loc, Ctx, 0);
5418 A->setImplicit(true);
5419 return A;
5420 }
5421
5422 NoSpeculativeLoadHardeningAttr(SourceRange R, ASTContext &Ctx
5423 , unsigned SI
5424 )
5425 : InheritableAttr(attr::NoSpeculativeLoadHardening, R, SI, false, false)
5426 {
5427 }
5428
5429 NoSpeculativeLoadHardeningAttr *clone(ASTContext &C) const;
5430 void printPretty(raw_ostream &OS,
5431 const PrintingPolicy &Policy) const;
5432 const char *getSpelling() const;
5433
5434
5435 static bool classof(const Attr *A) { return A->getKind() == attr::NoSpeculativeLoadHardening; }
5436};
5437
5438class NoSplitStackAttr : public InheritableAttr {
5439public:
5440 static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5441 auto *A = new (Ctx) NoSplitStackAttr(Loc, Ctx, 0);
5442 A->setImplicit(true);
5443 return A;
5444 }
5445
5446 NoSplitStackAttr(SourceRange R, ASTContext &Ctx
5447 , unsigned SI
5448 )
5449 : InheritableAttr(attr::NoSplitStack, R, SI, false, false)
5450 {
5451 }
5452
5453 NoSplitStackAttr *clone(ASTContext &C) const;
5454 void printPretty(raw_ostream &OS,
5455 const PrintingPolicy &Policy) const;
5456 const char *getSpelling() const;
5457
5458
5459 static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; }
5460};
5461
5462class NoStackProtectorAttr : public InheritableAttr {
5463public:
5464 static NoStackProtectorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5465 auto *A = new (Ctx) NoStackProtectorAttr(Loc, Ctx, 0);
5466 A->setImplicit(true);
5467 return A;
5468 }
5469
5470 NoStackProtectorAttr(SourceRange R, ASTContext &Ctx
5471 , unsigned SI
5472 )
5473 : InheritableAttr(attr::NoStackProtector, R, SI, false, false)
5474 {
5475 }
5476
5477 NoStackProtectorAttr *clone(ASTContext &C) const;
5478 void printPretty(raw_ostream &OS,
5479 const PrintingPolicy &Policy) const;
5480 const char *getSpelling() const;
5481
5482
5483 static bool classof(const Attr *A) { return A->getKind() == attr::NoStackProtector; }
5484};
5485
5486class NoThreadSafetyAnalysisAttr : public InheritableAttr {
5487public:
5488 static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5489 auto *A = new (Ctx) NoThreadSafetyAnalysisAttr(Loc, Ctx, 0);
5490 A->setImplicit(true);
5491 return A;
5492 }
5493
5494 NoThreadSafetyAnalysisAttr(SourceRange R, ASTContext &Ctx
5495 , unsigned SI
5496 )
5497 : InheritableAttr(attr::NoThreadSafetyAnalysis, R, SI, false, false)
5498 {
5499 }
5500
5501 NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const;
5502 void printPretty(raw_ostream &OS,
5503 const PrintingPolicy &Policy) const;
5504 const char *getSpelling() const;
5505
5506
5507 static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; }
5508};
5509
5510class NoThrowAttr : public InheritableAttr {
5511public:
5512 static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5513 auto *A = new (Ctx) NoThrowAttr(Loc, Ctx, 0);
5514 A->setImplicit(true);
5515 return A;
5516 }
5517
5518 NoThrowAttr(SourceRange R, ASTContext &Ctx
5519 , unsigned SI
5520 )
5521 : InheritableAttr(attr::NoThrow, R, SI, false, false)
5522 {
5523 }
5524
5525 NoThrowAttr *clone(ASTContext &C) const;
5526 void printPretty(raw_ostream &OS,
5527 const PrintingPolicy &Policy) const;
5528 const char *getSpelling() const;
5529
5530
5531 static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; }
5532};
5533
5534class NonNullAttr : public InheritableParamAttr {
5535 unsigned args_Size;
5536 ParamIdx *args_;
5537
5538public:
5539 static NonNullAttr *CreateImplicit(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
5540 auto *A = new (Ctx) NonNullAttr(Loc, Ctx, Args, ArgsSize, 0);
5541 A->setImplicit(true);
5542 return A;
5543 }
5544
5545 NonNullAttr(SourceRange R, ASTContext &Ctx
5546 , ParamIdx *Args, unsigned ArgsSize
5547 , unsigned SI
5548 )
5549 : InheritableParamAttr(attr::NonNull, R, SI, false, true)
5550 , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[args_Size])
5551 {
5552 std::copy(Args, Args + args_Size, args_);
5553 }
5554
5555 NonNullAttr(SourceRange R, ASTContext &Ctx
5556 , unsigned SI
5557 )
5558 : InheritableParamAttr(attr::NonNull, R, SI, false, true)
5559 , args_Size(0), args_(nullptr)
5560 {
5561 }
5562
5563 NonNullAttr *clone(ASTContext &C) const;
5564 void printPretty(raw_ostream &OS,
5565 const PrintingPolicy &Policy) const;
5566 const char *getSpelling() const;
5567 typedef ParamIdx* args_iterator;
5568 args_iterator args_begin() const { return args_; }
5569 args_iterator args_end() const { return args_ + args_Size; }
5570 unsigned args_size() const { return args_Size; }
5571 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5572
5573
5574
5575 bool isNonNull(unsigned IdxAST) const {
5576 if (!args_size())
5577 return true;
5578 return args_end() != std::find_if(
5579 args_begin(), args_end(),
5580 [=](const ParamIdx &Idx) { return Idx.getASTIndex() == IdxAST; });
5581 }
5582
5583
5584 static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
5585};
5586
5587class NotTailCalledAttr : public InheritableAttr {
5588public:
5589 static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5590 auto *A = new (Ctx) NotTailCalledAttr(Loc, Ctx, 0);
5591 A->setImplicit(true);
5592 return A;
5593 }
5594
5595 NotTailCalledAttr(SourceRange R, ASTContext &Ctx
5596 , unsigned SI
5597 )
5598 : InheritableAttr(attr::NotTailCalled, R, SI, false, false)
5599 {
5600 }
5601
5602 NotTailCalledAttr *clone(ASTContext &C) const;
5603 void printPretty(raw_ostream &OS,
5604 const PrintingPolicy &Policy) const;
5605 const char *getSpelling() const;
5606
5607
5608 static bool classof(const Attr *A) { return A->getKind() == attr::NotTailCalled; }
5609};
5610
5611class OMPAllocateDeclAttr : public InheritableAttr {
5612public:
5613 enum AllocatorTypeTy {
5614 OMPDefaultMemAlloc,
5615 OMPLargeCapMemAlloc,
5616 OMPConstMemAlloc,
5617 OMPHighBWMemAlloc,
5618 OMPLowLatMemAlloc,
5619 OMPCGroupMemAlloc,
5620 OMPPTeamMemAlloc,
5621 OMPThreadMemAlloc,
5622 OMPUserDefinedMemAlloc
5623 };
5624private:
5625 AllocatorTypeTy allocatorType;
5626
5627Expr * allocator;
5628
5629public:
5630 static OMPAllocateDeclAttr *CreateImplicit(ASTContext &Ctx, AllocatorTypeTy AllocatorType, Expr * Allocator, SourceRange Loc = SourceRange()) {
5631 auto *A = new (Ctx) OMPAllocateDeclAttr(Loc, Ctx, AllocatorType, Allocator, 0);
5632 A->setImplicit(true);
5633 return A;
5634 }
5635
5636 OMPAllocateDeclAttr(SourceRange R, ASTContext &Ctx
5637 , AllocatorTypeTy AllocatorType
5638 , Expr * Allocator
5639 , unsigned SI
5640 )
5641 : InheritableAttr(attr::OMPAllocateDecl, R, SI, false, false)
5642 , allocatorType(AllocatorType)
5643 , allocator(Allocator)
5644 {
5645 }
5646
5647 OMPAllocateDeclAttr *clone(ASTContext &C) const;
5648 void printPretty(raw_ostream &OS,
5649 const PrintingPolicy &Policy) const;
5650 const char *getSpelling() const;
5651 AllocatorTypeTy getAllocatorType() const {
5652 return allocatorType;
5653 }
5654
5655 static bool ConvertStrToAllocatorTypeTy(StringRef Val, AllocatorTypeTy &Out) {
5656 Optional<AllocatorTypeTy> R = llvm::StringSwitch<Optional<AllocatorTypeTy>>(Val)
5657 .Case("omp_default_mem_alloc", OMPAllocateDeclAttr::OMPDefaultMemAlloc)
5658 .Case("omp_large_cap_mem_alloc", OMPAllocateDeclAttr::OMPLargeCapMemAlloc)
5659 .Case("omp_const_mem_alloc", OMPAllocateDeclAttr::OMPConstMemAlloc)
5660 .Case("omp_high_bw_mem_alloc", OMPAllocateDeclAttr::OMPHighBWMemAlloc)
5661 .Case("omp_low_lat_mem_alloc", OMPAllocateDeclAttr::OMPLowLatMemAlloc)
5662 .Case("omp_cgroup_mem_alloc", OMPAllocateDeclAttr::OMPCGroupMemAlloc)
5663 .Case("omp_pteam_mem_alloc", OMPAllocateDeclAttr::OMPPTeamMemAlloc)
5664 .Case("omp_thread_mem_alloc", OMPAllocateDeclAttr::OMPThreadMemAlloc)
5665 .Case("", OMPAllocateDeclAttr::OMPUserDefinedMemAlloc)
5666 .Default(Optional<AllocatorTypeTy>());
5667 if (R) {
5668 Out = *R;
5669 return true;
5670 }
5671 return false;
5672 }
5673
5674 static const char *ConvertAllocatorTypeTyToStr(AllocatorTypeTy Val) {
5675 switch(Val) {
5676 case OMPAllocateDeclAttr::OMPDefaultMemAlloc: return "omp_default_mem_alloc";
5677 case OMPAllocateDeclAttr::OMPLargeCapMemAlloc: return "omp_large_cap_mem_alloc";
5678 case OMPAllocateDeclAttr::OMPConstMemAlloc: return "omp_const_mem_alloc";
5679 case OMPAllocateDeclAttr::OMPHighBWMemAlloc: return "omp_high_bw_mem_alloc";
5680 case OMPAllocateDeclAttr::OMPLowLatMemAlloc: return "omp_low_lat_mem_alloc";
5681 case OMPAllocateDeclAttr::OMPCGroupMemAlloc: return "omp_cgroup_mem_alloc";
5682 case OMPAllocateDeclAttr::OMPPTeamMemAlloc: return "omp_pteam_mem_alloc";
5683 case OMPAllocateDeclAttr::OMPThreadMemAlloc: return "omp_thread_mem_alloc";
5684 case OMPAllocateDeclAttr::OMPUserDefinedMemAlloc: return "";
5685 }
5686 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5686)
;
5687 }
5688 Expr * getAllocator() const {
5689 return allocator;
5690 }
5691
5692
5693
5694 static bool classof(const Attr *A) { return A->getKind() == attr::OMPAllocateDecl; }
5695};
5696
5697class OMPCaptureKindAttr : public Attr {
5698unsigned captureKind;
5699
5700public:
5701 static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKind, SourceRange Loc = SourceRange()) {
5702 auto *A = new (Ctx) OMPCaptureKindAttr(Loc, Ctx, CaptureKind, 0);
5703 A->setImplicit(true);
5704 return A;
5705 }
5706
5707 OMPCaptureKindAttr(SourceRange R, ASTContext &Ctx
5708 , unsigned CaptureKind
5709 , unsigned SI
5710 )
5711 : Attr(attr::OMPCaptureKind, R, SI, false)
5712 , captureKind(CaptureKind)
5713 {
5714 }
5715
5716 OMPCaptureKindAttr *clone(ASTContext &C) const;
5717 void printPretty(raw_ostream &OS,
5718 const PrintingPolicy &Policy) const;
5719 const char *getSpelling() const;
5720 unsigned getCaptureKind() const {
5721 return captureKind;
5722 }
5723
5724
5725
5726 static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureKind; }
5727};
5728
5729class OMPCaptureNoInitAttr : public InheritableAttr {
5730public:
5731 static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5732 auto *A = new (Ctx) OMPCaptureNoInitAttr(Loc, Ctx, 0);
5733 A->setImplicit(true);
5734 return A;
5735 }
5736
5737 OMPCaptureNoInitAttr(SourceRange R, ASTContext &Ctx
5738 , unsigned SI
5739 )
5740 : InheritableAttr(attr::OMPCaptureNoInit, R, SI, false, false)
5741 {
5742 }
5743
5744 OMPCaptureNoInitAttr *clone(ASTContext &C) const;
5745 void printPretty(raw_ostream &OS,
5746 const PrintingPolicy &Policy) const;
5747 const char *getSpelling() const;
5748
5749
5750 static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureNoInit; }
5751};
5752
5753class OMPDeclareSimdDeclAttr : public Attr {
5754public:
5755 enum BranchStateTy {
5756 BS_Undefined,
5757 BS_Inbranch,
5758 BS_Notinbranch
5759 };
5760private:
5761 BranchStateTy branchState;
5762
5763Expr * simdlen;
5764
5765 unsigned uniforms_Size;
5766 Expr * *uniforms_;
5767
5768 unsigned aligneds_Size;
5769 Expr * *aligneds_;
5770
5771 unsigned alignments_Size;
5772 Expr * *alignments_;
5773
5774 unsigned linears_Size;
5775 Expr * *linears_;
5776
5777 unsigned modifiers_Size;
5778 unsigned *modifiers_;
5779
5780 unsigned steps_Size;
5781 Expr * *steps_;
5782
5783public:
5784 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()) {
5785 auto *A = new (Ctx) OMPDeclareSimdDeclAttr(Loc, Ctx, BranchState, Simdlen, Uniforms, UniformsSize, Aligneds, AlignedsSize, Alignments, AlignmentsSize, Linears, LinearsSize, Modifiers, ModifiersSize, Steps, StepsSize, 0);
5786 A->setImplicit(true);
5787 return A;
5788 }
5789
5790 OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx
5791 , BranchStateTy BranchState
5792 , Expr * Simdlen
5793 , Expr * *Uniforms, unsigned UniformsSize
5794 , Expr * *Aligneds, unsigned AlignedsSize
5795 , Expr * *Alignments, unsigned AlignmentsSize
5796 , Expr * *Linears, unsigned LinearsSize
5797 , unsigned *Modifiers, unsigned ModifiersSize
5798 , Expr * *Steps, unsigned StepsSize
5799 , unsigned SI
5800 )
5801 : Attr(attr::OMPDeclareSimdDecl, R, SI, false)
5802 , branchState(BranchState)
5803 , simdlen(Simdlen)
5804 , uniforms_Size(UniformsSize), uniforms_(new (Ctx, 16) Expr *[uniforms_Size])
5805 , aligneds_Size(AlignedsSize), aligneds_(new (Ctx, 16) Expr *[aligneds_Size])
5806 , alignments_Size(AlignmentsSize), alignments_(new (Ctx, 16) Expr *[alignments_Size])
5807 , linears_Size(LinearsSize), linears_(new (Ctx, 16) Expr *[linears_Size])
5808 , modifiers_Size(ModifiersSize), modifiers_(new (Ctx, 16) unsigned[modifiers_Size])
5809 , steps_Size(StepsSize), steps_(new (Ctx, 16) Expr *[steps_Size])
5810 {
5811 std::copy(Uniforms, Uniforms + uniforms_Size, uniforms_);
5812 std::copy(Aligneds, Aligneds + aligneds_Size, aligneds_);
5813 std::copy(Alignments, Alignments + alignments_Size, alignments_);
5814 std::copy(Linears, Linears + linears_Size, linears_);
5815 std::copy(Modifiers, Modifiers + modifiers_Size, modifiers_);
5816 std::copy(Steps, Steps + steps_Size, steps_);
5817 }
5818
5819 OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx
5820 , BranchStateTy BranchState
5821 , Expr * Simdlen
5822 , unsigned SI
5823 )
5824 : Attr(attr::OMPDeclareSimdDecl, R, SI, false)
5825 , branchState(BranchState)
5826 , simdlen(Simdlen)
5827 , uniforms_Size(0), uniforms_(nullptr)
5828 , aligneds_Size(0), aligneds_(nullptr)
5829 , alignments_Size(0), alignments_(nullptr)
5830 , linears_Size(0), linears_(nullptr)
5831 , modifiers_Size(0), modifiers_(nullptr)
5832 , steps_Size(0), steps_(nullptr)
5833 {
5834 }
5835
5836 OMPDeclareSimdDeclAttr *clone(ASTContext &C) const;
5837 void printPretty(raw_ostream &OS,
5838 const PrintingPolicy &Policy) const;
5839 const char *getSpelling() const;
5840 BranchStateTy getBranchState() const {
5841 return branchState;
5842 }
5843
5844 static bool ConvertStrToBranchStateTy(StringRef Val, BranchStateTy &Out) {
5845 Optional<BranchStateTy> R = llvm::StringSwitch<Optional<BranchStateTy>>(Val)
5846 .Case("", OMPDeclareSimdDeclAttr::BS_Undefined)
5847 .Case("inbranch", OMPDeclareSimdDeclAttr::BS_Inbranch)
5848 .Case("notinbranch", OMPDeclareSimdDeclAttr::BS_Notinbranch)
5849 .Default(Optional<BranchStateTy>());
5850 if (R) {
5851 Out = *R;
5852 return true;
5853 }
5854 return false;
5855 }
5856
5857 static const char *ConvertBranchStateTyToStr(BranchStateTy Val) {
5858 switch(Val) {
5859 case OMPDeclareSimdDeclAttr::BS_Undefined: return "";
5860 case OMPDeclareSimdDeclAttr::BS_Inbranch: return "inbranch";
5861 case OMPDeclareSimdDeclAttr::BS_Notinbranch: return "notinbranch";
5862 }
5863 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5863)
;
5864 }
5865 Expr * getSimdlen() const {
5866 return simdlen;
5867 }
5868
5869 typedef Expr ** uniforms_iterator;
5870 uniforms_iterator uniforms_begin() const { return uniforms_; }
5871 uniforms_iterator uniforms_end() const { return uniforms_ + uniforms_Size; }
5872 unsigned uniforms_size() const { return uniforms_Size; }
5873 llvm::iterator_range<uniforms_iterator> uniforms() const { return llvm::make_range(uniforms_begin(), uniforms_end()); }
5874
5875
5876 typedef Expr ** aligneds_iterator;
5877 aligneds_iterator aligneds_begin() const { return aligneds_; }
5878 aligneds_iterator aligneds_end() const { return aligneds_ + aligneds_Size; }
5879 unsigned aligneds_size() const { return aligneds_Size; }
5880 llvm::iterator_range<aligneds_iterator> aligneds() const { return llvm::make_range(aligneds_begin(), aligneds_end()); }
5881
5882
5883 typedef Expr ** alignments_iterator;
5884 alignments_iterator alignments_begin() const { return alignments_; }
5885 alignments_iterator alignments_end() const { return alignments_ + alignments_Size; }
5886 unsigned alignments_size() const { return alignments_Size; }
5887 llvm::iterator_range<alignments_iterator> alignments() const { return llvm::make_range(alignments_begin(), alignments_end()); }
5888
5889
5890 typedef Expr ** linears_iterator;
5891 linears_iterator linears_begin() const { return linears_; }
5892 linears_iterator linears_end() const { return linears_ + linears_Size; }
5893 unsigned linears_size() const { return linears_Size; }
5894 llvm::iterator_range<linears_iterator> linears() const { return llvm::make_range(linears_begin(), linears_end()); }
5895
5896
5897 typedef unsigned* modifiers_iterator;
5898 modifiers_iterator modifiers_begin() const { return modifiers_; }
5899 modifiers_iterator modifiers_end() const { return modifiers_ + modifiers_Size; }
5900 unsigned modifiers_size() const { return modifiers_Size; }
5901 llvm::iterator_range<modifiers_iterator> modifiers() const { return llvm::make_range(modifiers_begin(), modifiers_end()); }
5902
5903
5904 typedef Expr ** steps_iterator;
5905 steps_iterator steps_begin() const { return steps_; }
5906 steps_iterator steps_end() const { return steps_ + steps_Size; }
5907 unsigned steps_size() const { return steps_Size; }
5908 llvm::iterator_range<steps_iterator> steps() const { return llvm::make_range(steps_begin(), steps_end()); }
5909
5910
5911
5912 void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
5913 const {
5914 if (getBranchState() != BS_Undefined)
5915 OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
5916 if (auto *E = getSimdlen()) {
5917 OS << " simdlen(";
5918 E->printPretty(OS, nullptr, Policy);
5919 OS << ")";
5920 }
5921 if (uniforms_size() > 0) {
5922 OS << " uniform";
5923 StringRef Sep = "(";
5924 for (auto *E : uniforms()) {
5925 OS << Sep;
5926 E->printPretty(OS, nullptr, Policy);
5927 Sep = ", ";
5928 }
5929 OS << ")";
5930 }
5931 alignments_iterator NI = alignments_begin();
5932 for (auto *E : aligneds()) {
5933 OS << " aligned(";
5934 E->printPretty(OS, nullptr, Policy);
5935 if (*NI) {
5936 OS << ": ";
5937 (*NI)->printPretty(OS, nullptr, Policy);
5938 }
5939 OS << ")";
5940 ++NI;
5941 }
5942 steps_iterator I = steps_begin();
5943 modifiers_iterator MI = modifiers_begin();
5944 for (auto *E : linears()) {
5945 OS << " linear(";
5946 if (*MI != OMPC_LINEAR_unknown)
5947 OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
5948 E->printPretty(OS, nullptr, Policy);
5949 if (*MI != OMPC_LINEAR_unknown)
5950 OS << ")";
5951 if (*I) {
5952 OS << ": ";
5953 (*I)->printPretty(OS, nullptr, Policy);
5954 }
5955 OS << ")";
5956 ++I;
5957 ++MI;
5958 }
5959 }
5960
5961
5962 static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareSimdDecl; }
5963};
5964
5965class OMPDeclareTargetDeclAttr : public InheritableAttr {
5966public:
5967 enum MapTypeTy {
5968 MT_To,
5969 MT_Link
5970 };
5971private:
5972 MapTypeTy mapType;
5973
5974public:
5975 static OMPDeclareTargetDeclAttr *CreateImplicit(ASTContext &Ctx, MapTypeTy MapType, SourceRange Loc = SourceRange()) {
5976 auto *A = new (Ctx) OMPDeclareTargetDeclAttr(Loc, Ctx, MapType, 0);
5977 A->setImplicit(true);
5978 return A;
5979 }
5980
5981 OMPDeclareTargetDeclAttr(SourceRange R, ASTContext &Ctx
5982 , MapTypeTy MapType
5983 , unsigned SI
5984 )
5985 : InheritableAttr(attr::OMPDeclareTargetDecl, R, SI, false, false)
5986 , mapType(MapType)
5987 {
5988 }
5989
5990 OMPDeclareTargetDeclAttr *clone(ASTContext &C) const;
5991 void printPretty(raw_ostream &OS,
5992 const PrintingPolicy &Policy) const;
5993 const char *getSpelling() const;
5994 MapTypeTy getMapType() const {
5995 return mapType;
5996 }
5997
5998 static bool ConvertStrToMapTypeTy(StringRef Val, MapTypeTy &Out) {
5999 Optional<MapTypeTy> R = llvm::StringSwitch<Optional<MapTypeTy>>(Val)
6000 .Case("to", OMPDeclareTargetDeclAttr::MT_To)
6001 .Case("link", OMPDeclareTargetDeclAttr::MT_Link)
6002 .Default(Optional<MapTypeTy>());
6003 if (R) {
6004 Out = *R;
6005 return true;
6006 }
6007 return false;
6008 }
6009
6010 static const char *ConvertMapTypeTyToStr(MapTypeTy Val) {
6011 switch(Val) {
6012 case OMPDeclareTargetDeclAttr::MT_To: return "to";
6013 case OMPDeclareTargetDeclAttr::MT_Link: return "link";
6014 }
6015 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6015)
;
6016 }
6017
6018 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
6019 // Use fake syntax because it is for testing and debugging purpose only.
6020 if (getMapType() != MT_To)
6021 OS << ' ' << ConvertMapTypeTyToStr(getMapType());
6022 }
6023 static llvm::Optional<MapTypeTy>
6024 isDeclareTargetDeclaration(const ValueDecl *VD) {
6025 if (!VD->hasAttrs())
6026 return llvm::None;
6027 if (const auto *Attr = VD->getAttr<OMPDeclareTargetDeclAttr>())
6028 return Attr->getMapType();
6029
6030 return llvm::None;
6031 }
6032
6033
6034 static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareTargetDecl; }
6035};
6036
6037class OMPReferencedVarAttr : public Attr {
6038Expr * ref;
6039
6040public:
6041 static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, SourceRange Loc = SourceRange()) {
6042 auto *A = new (Ctx) OMPReferencedVarAttr(Loc, Ctx, Ref, 0);
6043 A->setImplicit(true);
6044 return A;
6045 }
6046
6047 OMPReferencedVarAttr(SourceRange R, ASTContext &Ctx
6048 , Expr * Ref
6049 , unsigned SI
6050 )
6051 : Attr(attr::OMPReferencedVar, R, SI, false)
6052 , ref(Ref)
6053 {
6054 }
6055
6056 OMPReferencedVarAttr *clone(ASTContext &C) const;
6057 void printPretty(raw_ostream &OS,
6058 const PrintingPolicy &Policy) const;
6059 const char *getSpelling() const;
6060 Expr * getRef() const {
6061 return ref;
6062 }
6063
6064
6065
6066 static bool classof(const Attr *A) { return A->getKind() == attr::OMPReferencedVar; }
6067};
6068
6069class OMPThreadPrivateDeclAttr : public InheritableAttr {
6070public:
6071 static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6072 auto *A = new (Ctx) OMPThreadPrivateDeclAttr(Loc, Ctx, 0);
6073 A->setImplicit(true);
6074 return A;
6075 }
6076
6077 OMPThreadPrivateDeclAttr(SourceRange R, ASTContext &Ctx
6078 , unsigned SI
6079 )
6080 : InheritableAttr(attr::OMPThreadPrivateDecl, R, SI, false, false)
6081 {
6082 }
6083
6084 OMPThreadPrivateDeclAttr *clone(ASTContext &C) const;
6085 void printPretty(raw_ostream &OS,
6086 const PrintingPolicy &Policy) const;
6087 const char *getSpelling() const;
6088
6089
6090 static bool classof(const Attr *A) { return A->getKind() == attr::OMPThreadPrivateDecl; }
6091};
6092
6093class OSConsumedAttr : public InheritableParamAttr {
6094public:
6095 static OSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6096 auto *A = new (Ctx) OSConsumedAttr(Loc, Ctx, 0);
6097 A->setImplicit(true);
6098 return A;
6099 }
6100
6101 OSConsumedAttr(SourceRange R, ASTContext &Ctx
6102 , unsigned SI
6103 )
6104 : InheritableParamAttr(attr::OSConsumed, R, SI, false, false)
6105 {
6106 }
6107
6108 OSConsumedAttr *clone(ASTContext &C) const;
6109 void printPretty(raw_ostream &OS,
6110 const PrintingPolicy &Policy) const;
6111 const char *getSpelling() const;
6112
6113
6114 static bool classof(const Attr *A) { return A->getKind() == attr::OSConsumed; }
6115};
6116
6117class OSConsumesThisAttr : public InheritableAttr {
6118public:
6119 static OSConsumesThisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6120 auto *A = new (Ctx) OSConsumesThisAttr(Loc, Ctx, 0);
6121 A->setImplicit(true);
6122 return A;
6123 }
6124
6125 OSConsumesThisAttr(SourceRange R, ASTContext &Ctx
6126 , unsigned SI
6127 )
6128 : InheritableAttr(attr::OSConsumesThis, R, SI, false, false)
6129 {
6130 }
6131
6132 OSConsumesThisAttr *clone(ASTContext &C) const;
6133 void printPretty(raw_ostream &OS,
6134 const PrintingPolicy &Policy) const;
6135 const char *getSpelling() const;
6136
6137
6138 static bool classof(const Attr *A) { return A->getKind() == attr::OSConsumesThis; }
6139};
6140
6141class OSReturnsNotRetainedAttr : public InheritableAttr {
6142public:
6143 static OSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6144 auto *A = new (Ctx) OSReturnsNotRetainedAttr(Loc, Ctx, 0);
6145 A->setImplicit(true);
6146 return A;
6147 }
6148
6149 OSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
6150 , unsigned SI
6151 )
6152 : InheritableAttr(attr::OSReturnsNotRetained, R, SI, false, false)
6153 {
6154 }
6155
6156 OSReturnsNotRetainedAttr *clone(ASTContext &C) const;
6157 void printPretty(raw_ostream &OS,
6158 const PrintingPolicy &Policy) const;
6159 const char *getSpelling() const;
6160
6161
6162 static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsNotRetained; }
6163};
6164
6165class OSReturnsRetainedAttr : public InheritableAttr {
6166public:
6167 static OSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6168 auto *A = new (Ctx) OSReturnsRetainedAttr(Loc, Ctx, 0);
6169 A->setImplicit(true);
6170 return A;
6171 }
6172
6173 OSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
6174 , unsigned SI
6175 )
6176 : InheritableAttr(attr::OSReturnsRetained, R, SI, false, false)
6177 {
6178 }
6179
6180 OSReturnsRetainedAttr *clone(ASTContext &C) const;
6181 void printPretty(raw_ostream &OS,
6182 const PrintingPolicy &Policy) const;
6183 const char *getSpelling() const;
6184
6185
6186 static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsRetained; }
6187};
6188
6189class OSReturnsRetainedOnNonZeroAttr : public InheritableAttr {
6190public:
6191 static OSReturnsRetainedOnNonZeroAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6192 auto *A = new (Ctx) OSReturnsRetainedOnNonZeroAttr(Loc, Ctx, 0);
6193 A->setImplicit(true);
6194 return A;
6195 }
6196
6197 OSReturnsRetainedOnNonZeroAttr(SourceRange R, ASTContext &Ctx
6198 , unsigned SI
6199 )
6200 : InheritableAttr(attr::OSReturnsRetainedOnNonZero, R, SI, false, false)
6201 {
6202 }
6203
6204 OSReturnsRetainedOnNonZeroAttr *clone(ASTContext &C) const;
6205 void printPretty(raw_ostream &OS,
6206 const PrintingPolicy &Policy) const;
6207 const char *getSpelling() const;
6208
6209
6210 static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsRetainedOnNonZero; }
6211};
6212
6213class OSReturnsRetainedOnZeroAttr : public InheritableAttr {
6214public:
6215 static OSReturnsRetainedOnZeroAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6216 auto *A = new (Ctx) OSReturnsRetainedOnZeroAttr(Loc, Ctx, 0);
6217 A->setImplicit(true);
6218 return A;
6219 }
6220
6221 OSReturnsRetainedOnZeroAttr(SourceRange R, ASTContext &Ctx
6222 , unsigned SI
6223 )
6224 : InheritableAttr(attr::OSReturnsRetainedOnZero, R, SI, false, false)
6225 {
6226 }
6227
6228 OSReturnsRetainedOnZeroAttr *clone(ASTContext &C) const;
6229 void printPretty(raw_ostream &OS,
6230 const PrintingPolicy &Policy) const;
6231 const char *getSpelling() const;
6232
6233
6234 static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsRetainedOnZero; }
6235};
6236
6237class ObjCBoxableAttr : public Attr {
6238public:
6239 static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6240 auto *A = new (Ctx) ObjCBoxableAttr(Loc, Ctx, 0);
6241 A->setImplicit(true);
6242 return A;
6243 }
6244
6245 ObjCBoxableAttr(SourceRange R, ASTContext &Ctx
6246 , unsigned SI
6247 )
6248 : Attr(attr::ObjCBoxable, R, SI, false)
6249 {
6250 }
6251
6252 ObjCBoxableAttr *clone(ASTContext &C) const;
6253 void printPretty(raw_ostream &OS,
6254 const PrintingPolicy &Policy) const;
6255 const char *getSpelling() const;
6256
6257
6258 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBoxable; }
6259};
6260
6261class ObjCBridgeAttr : public InheritableAttr {
6262IdentifierInfo * bridgedType;
6263
6264public:
6265 static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
6266 auto *A = new (Ctx) ObjCBridgeAttr(Loc, Ctx, BridgedType, 0);
6267 A->setImplicit(true);
6268 return A;
6269 }
6270
6271 ObjCBridgeAttr(SourceRange R, ASTContext &Ctx
6272 , IdentifierInfo * BridgedType
6273 , unsigned SI
6274 )
6275 : InheritableAttr(attr::ObjCBridge, R, SI, false, false)
6276 , bridgedType(BridgedType)
6277 {
6278 }
6279
6280 ObjCBridgeAttr *clone(ASTContext &C) const;
6281 void printPretty(raw_ostream &OS,
6282 const PrintingPolicy &Policy) const;
6283 const char *getSpelling() const;
6284 IdentifierInfo * getBridgedType() const {
6285 return bridgedType;
6286 }
6287
6288
6289
6290 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridge; }
6291};
6292
6293class ObjCBridgeMutableAttr : public InheritableAttr {
6294IdentifierInfo * bridgedType;
6295
6296public:
6297 static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
6298 auto *A = new (Ctx) ObjCBridgeMutableAttr(Loc, Ctx, BridgedType, 0);
6299 A->setImplicit(true);
6300 return A;
6301 }
6302
6303 ObjCBridgeMutableAttr(SourceRange R, ASTContext &Ctx
6304 , IdentifierInfo * BridgedType
6305 , unsigned SI
6306 )
6307 : InheritableAttr(attr::ObjCBridgeMutable, R, SI, false, false)
6308 , bridgedType(BridgedType)
6309 {
6310 }
6311
6312 ObjCBridgeMutableAttr *clone(ASTContext &C) const;
6313 void printPretty(raw_ostream &OS,
6314 const PrintingPolicy &Policy) const;
6315 const char *getSpelling() const;
6316 IdentifierInfo * getBridgedType() const {
6317 return bridgedType;
6318 }
6319
6320
6321
6322 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeMutable; }
6323};
6324
6325class ObjCBridgeRelatedAttr : public InheritableAttr {
6326IdentifierInfo * relatedClass;
6327
6328IdentifierInfo * classMethod;
6329
6330IdentifierInfo * instanceMethod;
6331
6332public:
6333 static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Loc = SourceRange()) {
6334 auto *A = new (Ctx) ObjCBridgeRelatedAttr(Loc, Ctx, RelatedClass, ClassMethod, InstanceMethod, 0);
6335 A->setImplicit(true);
6336 return A;
6337 }
6338
6339 ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx
6340 , IdentifierInfo * RelatedClass
6341 , IdentifierInfo * ClassMethod
6342 , IdentifierInfo * InstanceMethod
6343 , unsigned SI
6344 )
6345 : InheritableAttr(attr::ObjCBridgeRelated, R, SI, false, false)
6346 , relatedClass(RelatedClass)
6347 , classMethod(ClassMethod)
6348 , instanceMethod(InstanceMethod)
6349 {
6350 }
6351
6352 ObjCBridgeRelatedAttr *clone(ASTContext &C) const;
6353 void printPretty(raw_ostream &OS,
6354 const PrintingPolicy &Policy) const;
6355 const char *getSpelling() const;
6356 IdentifierInfo * getRelatedClass() const {
6357 return relatedClass;
6358 }
6359
6360 IdentifierInfo * getClassMethod() const {
6361 return classMethod;
6362 }
6363
6364 IdentifierInfo * getInstanceMethod() const {
6365 return instanceMethod;
6366 }
6367
6368
6369
6370 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeRelated; }
6371};
6372
6373class ObjCClassStubAttr : public Attr {
6374public:
6375 static ObjCClassStubAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6376 auto *A = new (Ctx) ObjCClassStubAttr(Loc, Ctx, 0);
6377 A->setImplicit(true);
6378 return A;
6379 }
6380
6381 ObjCClassStubAttr(SourceRange R, ASTContext &Ctx
6382 , unsigned SI
6383 )
6384 : Attr(attr::ObjCClassStub, R, SI, false)
6385 {
6386 }
6387
6388 ObjCClassStubAttr *clone(ASTContext &C) const;
6389 void printPretty(raw_ostream &OS,
6390 const PrintingPolicy &Policy) const;
6391 const char *getSpelling() const;
6392
6393
6394 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCClassStub; }
6395};
6396
6397class ObjCDesignatedInitializerAttr : public Attr {
6398public:
6399 static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6400 auto *A = new (Ctx) ObjCDesignatedInitializerAttr(Loc, Ctx, 0);
6401 A->setImplicit(true);
6402 return A;
6403 }
6404
6405 ObjCDesignatedInitializerAttr(SourceRange R, ASTContext &Ctx
6406 , unsigned SI
6407 )
6408 : Attr(attr::ObjCDesignatedInitializer, R, SI, false)
6409 {
6410 }
6411
6412 ObjCDesignatedInitializerAttr *clone(ASTContext &C) const;
6413 void printPretty(raw_ostream &OS,
6414 const PrintingPolicy &Policy) const;
6415 const char *getSpelling() const;
6416
6417
6418 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDesignatedInitializer; }
6419};
6420
6421class ObjCExceptionAttr : public InheritableAttr {
6422public:
6423 static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6424 auto *A = new (Ctx) ObjCExceptionAttr(Loc, Ctx, 0);
6425 A->setImplicit(true);
6426 return A;
6427 }
6428
6429 ObjCExceptionAttr(SourceRange R, ASTContext &Ctx
6430 , unsigned SI
6431 )
6432 : InheritableAttr(attr::ObjCException, R, SI, false, false)
6433 {
6434 }
6435
6436 ObjCExceptionAttr *clone(ASTContext &C) const;
6437 void printPretty(raw_ostream &OS,
6438 const PrintingPolicy &Policy) const;
6439 const char *getSpelling() const;
6440
6441
6442 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCException; }
6443};
6444
6445class ObjCExplicitProtocolImplAttr : public InheritableAttr {
6446public:
6447 static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6448 auto *A = new (Ctx) ObjCExplicitProtocolImplAttr(Loc, Ctx, 0);
6449 A->setImplicit(true);
6450 return A;
6451 }
6452
6453 ObjCExplicitProtocolImplAttr(SourceRange R, ASTContext &Ctx
6454 , unsigned SI
6455 )
6456 : InheritableAttr(attr::ObjCExplicitProtocolImpl, R, SI, false, false)
6457 {
6458 }
6459
6460 ObjCExplicitProtocolImplAttr *clone(ASTContext &C) const;
6461 void printPretty(raw_ostream &OS,
6462 const PrintingPolicy &Policy) const;
6463 const char *getSpelling() const;
6464
6465
6466 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExplicitProtocolImpl; }
6467};
6468
6469class ObjCExternallyRetainedAttr : public InheritableAttr {
6470public:
6471 static ObjCExternallyRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6472 auto *A = new (Ctx) ObjCExternallyRetainedAttr(Loc, Ctx, 0);
6473 A->setImplicit(true);
6474 return A;
6475 }
6476
6477 ObjCExternallyRetainedAttr(SourceRange R, ASTContext &Ctx
6478 , unsigned SI
6479 )
6480 : InheritableAttr(attr::ObjCExternallyRetained, R, SI, false, false)
6481 {
6482 }
6483
6484 ObjCExternallyRetainedAttr *clone(ASTContext &C) const;
6485 void printPretty(raw_ostream &OS,
6486 const PrintingPolicy &Policy) const;
6487 const char *getSpelling() const;
6488
6489
6490 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExternallyRetained; }
6491};
6492
6493class ObjCGCAttr : public TypeAttr {
6494IdentifierInfo * kind;
6495
6496public:
6497 static ObjCGCAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Loc = SourceRange()) {
6498 auto *A = new (Ctx) ObjCGCAttr(Loc, Ctx, Kind, 0);
6499 A->setImplicit(true);
6500 return A;
6501 }
6502
6503 ObjCGCAttr(SourceRange R, ASTContext &Ctx
6504 , IdentifierInfo * Kind
6505 , unsigned SI
6506 )
6507 : TypeAttr(attr::ObjCGC, R, SI, false)
6508 , kind(Kind)
6509 {
6510 }
6511
6512 ObjCGCAttr *clone(ASTContext &C) const;
6513 void printPretty(raw_ostream &OS,
6514 const PrintingPolicy &Policy) const;
6515 const char *getSpelling() const;
6516 IdentifierInfo * getKind() const {
6517 return kind;
6518 }
6519
6520
6521
6522 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCGC; }
6523};
6524
6525class ObjCIndependentClassAttr : public InheritableAttr {
6526public:
6527 static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6528 auto *A = new (Ctx) ObjCIndependentClassAttr(Loc, Ctx, 0);
6529 A->setImplicit(true);
6530 return A;
6531 }
6532
6533 ObjCIndependentClassAttr(SourceRange R, ASTContext &Ctx
6534 , unsigned SI
6535 )
6536 : InheritableAttr(attr::ObjCIndependentClass, R, SI, false, false)
6537 {
6538 }
6539
6540 ObjCIndependentClassAttr *clone(ASTContext &C) const;
6541 void printPretty(raw_ostream &OS,
6542 const PrintingPolicy &Policy) const;
6543 const char *getSpelling() const;
6544
6545
6546 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCIndependentClass; }
6547};
6548
6549class ObjCInertUnsafeUnretainedAttr : public TypeAttr {
6550public:
6551 static ObjCInertUnsafeUnretainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6552 auto *A = new (Ctx) ObjCInertUnsafeUnretainedAttr(Loc, Ctx, 0);
6553 A->setImplicit(true);
6554 return A;
6555 }
6556
6557 ObjCInertUnsafeUnretainedAttr(SourceRange R, ASTContext &Ctx
6558 , unsigned SI
6559 )
6560 : TypeAttr(attr::ObjCInertUnsafeUnretained, R, SI, false)
6561 {
6562 }
6563
6564 ObjCInertUnsafeUnretainedAttr *clone(ASTContext &C) const;
6565 void printPretty(raw_ostream &OS,
6566 const PrintingPolicy &Policy) const;
6567 const char *getSpelling() const;
6568
6569
6570 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCInertUnsafeUnretained; }
6571};
6572
6573class ObjCKindOfAttr : public TypeAttr {
6574public:
6575 static ObjCKindOfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6576 auto *A = new (Ctx) ObjCKindOfAttr(Loc, Ctx, 0);
6577 A->setImplicit(true);
6578 return A;
6579 }
6580
6581 ObjCKindOfAttr(SourceRange R, ASTContext &Ctx
6582 , unsigned SI
6583 )
6584 : TypeAttr(attr::ObjCKindOf, R, SI, false)
6585 {
6586 }
6587
6588 ObjCKindOfAttr *clone(ASTContext &C) const;
6589 void printPretty(raw_ostream &OS,
6590 const PrintingPolicy &Policy) const;
6591 const char *getSpelling() const;
6592
6593
6594 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCKindOf; }
6595};
6596
6597class ObjCMethodFamilyAttr : public InheritableAttr {
6598public:
6599 enum FamilyKind {
6600 OMF_None,
6601 OMF_alloc,
6602 OMF_copy,
6603 OMF_init,
6604 OMF_mutableCopy,
6605 OMF_new
6606 };
6607private:
6608 FamilyKind family;
6609
6610public:
6611 static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, FamilyKind Family, SourceRange Loc = SourceRange()) {
6612 auto *A = new (Ctx) ObjCMethodFamilyAttr(Loc, Ctx, Family, 0);
6613 A->setImplicit(true);
6614 return A;
6615 }
6616
6617 ObjCMethodFamilyAttr(SourceRange R, ASTContext &Ctx
6618 , FamilyKind Family
6619 , unsigned SI
6620 )
6621 : InheritableAttr(attr::ObjCMethodFamily, R, SI, false, false)
6622 , family(Family)
6623 {
6624 }
6625
6626 ObjCMethodFamilyAttr *clone(ASTContext &C) const;
6627 void printPretty(raw_ostream &OS,
6628 const PrintingPolicy &Policy) const;
6629 const char *getSpelling() const;
6630 FamilyKind getFamily() const {
6631 return family;
6632 }
6633
6634 static bool ConvertStrToFamilyKind(StringRef Val, FamilyKind &Out) {
6635 Optional<FamilyKind> R = llvm::StringSwitch<Optional<FamilyKind>>(Val)
6636 .Case("none", ObjCMethodFamilyAttr::OMF_None)
6637 .Case("alloc", ObjCMethodFamilyAttr::OMF_alloc)
6638 .Case("copy", ObjCMethodFamilyAttr::OMF_copy)
6639 .Case("init", ObjCMethodFamilyAttr::OMF_init)
6640 .Case("mutableCopy", ObjCMethodFamilyAttr::OMF_mutableCopy)
6641 .Case("new", ObjCMethodFamilyAttr::OMF_new)
6642 .Default(Optional<FamilyKind>());
6643 if (R) {
6644 Out = *R;
6645 return true;
6646 }
6647 return false;
6648 }
6649
6650 static const char *ConvertFamilyKindToStr(FamilyKind Val) {
6651 switch(Val) {
6652 case ObjCMethodFamilyAttr::OMF_None: return "none";
6653 case ObjCMethodFamilyAttr::OMF_alloc: return "alloc";
6654 case ObjCMethodFamilyAttr::OMF_copy: return "copy";
6655 case ObjCMethodFamilyAttr::OMF_init: return "init";
6656 case ObjCMethodFamilyAttr::OMF_mutableCopy: return "mutableCopy";
6657 case ObjCMethodFamilyAttr::OMF_new: return "new";
6658 }
6659 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6659)
;
6660 }
6661
6662
6663 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; }
6664};
6665
6666class ObjCNSObjectAttr : public InheritableAttr {
6667public:
6668 static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6669 auto *A = new (Ctx) ObjCNSObjectAttr(Loc, Ctx, 0);
6670 A->setImplicit(true);
6671 return A;
6672 }
6673
6674 ObjCNSObjectAttr(SourceRange R, ASTContext &Ctx
6675 , unsigned SI
6676 )
6677 : InheritableAttr(attr::ObjCNSObject, R, SI, false, false)
6678 {
6679 }
6680
6681 ObjCNSObjectAttr *clone(ASTContext &C) const;
6682 void printPretty(raw_ostream &OS,
6683 const PrintingPolicy &Policy) const;
6684 const char *getSpelling() const;
6685
6686
6687 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNSObject; }
6688};
6689
6690class ObjCNonLazyClassAttr : public Attr {
6691public:
6692 static ObjCNonLazyClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6693 auto *A = new (Ctx) ObjCNonLazyClassAttr(Loc, Ctx, 0);
6694 A->setImplicit(true);
6695 return A;
6696 }
6697
6698 ObjCNonLazyClassAttr(SourceRange R, ASTContext &Ctx
6699 , unsigned SI
6700 )
6701 : Attr(attr::ObjCNonLazyClass, R, SI, false)
6702 {
6703 }
6704
6705 ObjCNonLazyClassAttr *clone(ASTContext &C) const;
6706 void printPretty(raw_ostream &OS,
6707 const PrintingPolicy &Policy) const;
6708 const char *getSpelling() const;
6709
6710
6711 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNonLazyClass; }
6712};
6713
6714class ObjCOwnershipAttr : public InheritableAttr {
6715IdentifierInfo * kind;
6716
6717public:
6718 static ObjCOwnershipAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Loc = SourceRange()) {
6719 auto *A = new (Ctx) ObjCOwnershipAttr(Loc, Ctx, Kind, 0);
6720 A->setImplicit(true);
6721 return A;
6722 }
6723
6724 ObjCOwnershipAttr(SourceRange R, ASTContext &Ctx
6725 , IdentifierInfo * Kind
6726 , unsigned SI
6727 )
6728 : InheritableAttr(attr::ObjCOwnership, R, SI, false, false)
6729 , kind(Kind)
6730 {
6731 }
6732
6733 ObjCOwnershipAttr *clone(ASTContext &C) const;
6734 void printPretty(raw_ostream &OS,
6735 const PrintingPolicy &Policy) const;
6736 const char *getSpelling() const;
6737 IdentifierInfo * getKind() const {
6738 return kind;
6739 }
6740
6741
6742
6743 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCOwnership; }
6744};
6745
6746class ObjCPreciseLifetimeAttr : public InheritableAttr {
6747public:
6748 static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6749 auto *A = new (Ctx) ObjCPreciseLifetimeAttr(Loc, Ctx, 0);
6750 A->setImplicit(true);
6751 return A;
6752 }
6753
6754 ObjCPreciseLifetimeAttr(SourceRange R, ASTContext &Ctx
6755 , unsigned SI
6756 )
6757 : InheritableAttr(attr::ObjCPreciseLifetime, R, SI, false, false)
6758 {
6759 }
6760
6761 ObjCPreciseLifetimeAttr *clone(ASTContext &C) const;
6762 void printPretty(raw_ostream &OS,
6763 const PrintingPolicy &Policy) const;
6764 const char *getSpelling() const;
6765
6766
6767 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCPreciseLifetime; }
6768};
6769
6770class ObjCRequiresPropertyDefsAttr : public InheritableAttr {
6771public:
6772 static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6773 auto *A = new (Ctx) ObjCRequiresPropertyDefsAttr(Loc, Ctx, 0);
6774 A->setImplicit(true);
6775 return A;
6776 }
6777
6778 ObjCRequiresPropertyDefsAttr(SourceRange R, ASTContext &Ctx
6779 , unsigned SI
6780 )
6781 : InheritableAttr(attr::ObjCRequiresPropertyDefs, R, SI, false, false)
6782 {
6783 }
6784
6785 ObjCRequiresPropertyDefsAttr *clone(ASTContext &C) const;
6786 void printPretty(raw_ostream &OS,
6787 const PrintingPolicy &Policy) const;
6788 const char *getSpelling() const;
6789
6790
6791 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresPropertyDefs; }
6792};
6793
6794class ObjCRequiresSuperAttr : public InheritableAttr {
6795public:
6796 static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6797 auto *A = new (Ctx) ObjCRequiresSuperAttr(Loc, Ctx, 0);
6798 A->setImplicit(true);
6799 return A;
6800 }
6801
6802 ObjCRequiresSuperAttr(SourceRange R, ASTContext &Ctx
6803 , unsigned SI
6804 )
6805 : InheritableAttr(attr::ObjCRequiresSuper, R, SI, false, false)
6806 {
6807 }
6808
6809 ObjCRequiresSuperAttr *clone(ASTContext &C) const;
6810 void printPretty(raw_ostream &OS,
6811 const PrintingPolicy &Policy) const;
6812 const char *getSpelling() const;
6813
6814
6815 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresSuper; }
6816};
6817
6818class ObjCReturnsInnerPointerAttr : public InheritableAttr {
6819public:
6820 static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6821 auto *A = new (Ctx) ObjCReturnsInnerPointerAttr(Loc, Ctx, 0);
6822 A->setImplicit(true);
6823 return A;
6824 }
6825
6826 ObjCReturnsInnerPointerAttr(SourceRange R, ASTContext &Ctx
6827 , unsigned SI
6828 )
6829 : InheritableAttr(attr::ObjCReturnsInnerPointer, R, SI, false, false)
6830 {
6831 }
6832
6833 ObjCReturnsInnerPointerAttr *clone(ASTContext &C) const;
6834 void printPretty(raw_ostream &OS,
6835 const PrintingPolicy &Policy) const;
6836 const char *getSpelling() const;
6837
6838
6839 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCReturnsInnerPointer; }
6840};
6841
6842class ObjCRootClassAttr : public InheritableAttr {
6843public:
6844 static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6845 auto *A = new (Ctx) ObjCRootClassAttr(Loc, Ctx, 0);
6846 A->setImplicit(true);
6847 return A;
6848 }
6849
6850 ObjCRootClassAttr(SourceRange R, ASTContext &Ctx
6851 , unsigned SI
6852 )
6853 : InheritableAttr(attr::ObjCRootClass, R, SI, false, false)
6854 {
6855 }
6856
6857 ObjCRootClassAttr *clone(ASTContext &C) const;
6858 void printPretty(raw_ostream &OS,
6859 const PrintingPolicy &Policy) const;
6860 const char *getSpelling() const;
6861
6862
6863 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRootClass; }
6864};
6865
6866class ObjCRuntimeNameAttr : public Attr {
6867unsigned metadataNameLength;
6868char *metadataName;
6869
6870public:
6871 static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Loc = SourceRange()) {
6872 auto *A = new (Ctx) ObjCRuntimeNameAttr(Loc, Ctx, MetadataName, 0);
6873 A->setImplicit(true);
6874 return A;
6875 }
6876
6877 ObjCRuntimeNameAttr(SourceRange R, ASTContext &Ctx
6878 , llvm::StringRef MetadataName
6879 , unsigned SI
6880 )
6881 : Attr(attr::ObjCRuntimeName, R, SI, false)
6882 , metadataNameLength(MetadataName.size()),metadataName(new (Ctx, 1) char[metadataNameLength])
6883 {
6884 if (!MetadataName.empty())
6885 std::memcpy(metadataName, MetadataName.data(), metadataNameLength);
6886 }
6887
6888 ObjCRuntimeNameAttr *clone(ASTContext &C) const;
6889 void printPretty(raw_ostream &OS,
6890 const PrintingPolicy &Policy) const;
6891 const char *getSpelling() const;
6892 llvm::StringRef getMetadataName() const {
6893 return llvm::StringRef(metadataName, metadataNameLength);
6894 }
6895 unsigned getMetadataNameLength() const {
6896 return metadataNameLength;
6897 }
6898 void setMetadataName(ASTContext &C, llvm::StringRef S) {
6899 metadataNameLength = S.size();
6900 this->metadataName = new (C, 1) char [metadataNameLength];
6901 if (!S.empty())
6902 std::memcpy(this->metadataName, S.data(), metadataNameLength);
6903 }
6904
6905
6906
6907 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeName; }
6908};
6909
6910class ObjCRuntimeVisibleAttr : public Attr {
6911public:
6912 static ObjCRuntimeVisibleAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6913 auto *A = new (Ctx) ObjCRuntimeVisibleAttr(Loc, Ctx, 0);
6914 A->setImplicit(true);
6915 return A;
6916 }
6917
6918 ObjCRuntimeVisibleAttr(SourceRange R, ASTContext &Ctx
6919 , unsigned SI
6920 )
6921 : Attr(attr::ObjCRuntimeVisible, R, SI, false)
6922 {
6923 }
6924
6925 ObjCRuntimeVisibleAttr *clone(ASTContext &C) const;
6926 void printPretty(raw_ostream &OS,
6927 const PrintingPolicy &Policy) const;
6928 const char *getSpelling() const;
6929
6930
6931 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeVisible; }
6932};
6933
6934class ObjCSubclassingRestrictedAttr : public InheritableAttr {
6935public:
6936 static ObjCSubclassingRestrictedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6937 auto *A = new (Ctx) ObjCSubclassingRestrictedAttr(Loc, Ctx, 0);
6938 A->setImplicit(true);
6939 return A;
6940 }
6941
6942 ObjCSubclassingRestrictedAttr(SourceRange R, ASTContext &Ctx
6943 , unsigned SI
6944 )
6945 : InheritableAttr(attr::ObjCSubclassingRestricted, R, SI, false, false)
6946 {
6947 }
6948
6949 ObjCSubclassingRestrictedAttr *clone(ASTContext &C) const;
6950 void printPretty(raw_ostream &OS,
6951 const PrintingPolicy &Policy) const;
6952 const char *getSpelling() const;
6953
6954
6955 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCSubclassingRestricted; }
6956};
6957
6958class OpenCLAccessAttr : public Attr {
6959public:
6960 enum Spelling {
6961 Keyword_read_only = 0,
6962 Keyword_write_only = 2,
6963 Keyword_read_write = 4
6964 };
6965
6966 static OpenCLAccessAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
6967 auto *A = new (Ctx) OpenCLAccessAttr(Loc, Ctx, S);
6968 A->setImplicit(true);
6969 return A;
6970 }
6971
6972 OpenCLAccessAttr(SourceRange R, ASTContext &Ctx
6973 , unsigned SI
6974 )
6975 : Attr(attr::OpenCLAccess, R, SI, false)
6976 {
6977 }
6978
6979 OpenCLAccessAttr *clone(ASTContext &C) const;
6980 void printPretty(raw_ostream &OS,
6981 const PrintingPolicy &Policy) const;
6982 const char *getSpelling() const;
6983 Spelling getSemanticSpelling() const {
6984 switch (SpellingListIndex) {
6985 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6985)
;
6986 case 0: return Keyword_read_only;
6987 case 1: return Keyword_read_only;
6988 case 2: return Keyword_write_only;
6989 case 3: return Keyword_write_only;
6990 case 4: return Keyword_read_write;
6991 case 5: return Keyword_read_write;
6992 }
6993 }
6994 bool isReadOnly() const { return SpellingListIndex == 0 ||
6995 SpellingListIndex == 1; }
6996 bool isReadWrite() const { return SpellingListIndex == 4 ||
6997 SpellingListIndex == 5; }
6998 bool isWriteOnly() const { return SpellingListIndex == 2 ||
6999 SpellingListIndex == 3; }
7000
7001
7002 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLAccess; }
7003};
7004
7005class OpenCLConstantAddressSpaceAttr : public TypeAttr {
7006public:
7007 static OpenCLConstantAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7008 auto *A = new (Ctx) OpenCLConstantAddressSpaceAttr(Loc, Ctx, 0);
7009 A->setImplicit(true);
7010 return A;
7011 }
7012
7013 OpenCLConstantAddressSpaceAttr(SourceRange R, ASTContext &Ctx
7014 , unsigned SI
7015 )
7016 : TypeAttr(attr::OpenCLConstantAddressSpace, R, SI, false)
7017 {
7018 }
7019
7020 OpenCLConstantAddressSpaceAttr *clone(ASTContext &C) const;
7021 void printPretty(raw_ostream &OS,
7022 const PrintingPolicy &Policy) const;
7023 const char *getSpelling() const;
7024
7025
7026 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLConstantAddressSpace; }
7027};
7028
7029class OpenCLGenericAddressSpaceAttr : public TypeAttr {
7030public:
7031 static OpenCLGenericAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7032 auto *A = new (Ctx) OpenCLGenericAddressSpaceAttr(Loc, Ctx, 0);
7033 A->setImplicit(true);
7034 return A;
7035 }
7036
7037 OpenCLGenericAddressSpaceAttr(SourceRange R, ASTContext &Ctx
7038 , unsigned SI
7039 )
7040 : TypeAttr(attr::OpenCLGenericAddressSpace, R, SI, false)
7041 {
7042 }
7043
7044 OpenCLGenericAddressSpaceAttr *clone(ASTContext &C) const;
7045 void printPretty(raw_ostream &OS,
7046 const PrintingPolicy &Policy) const;
7047 const char *getSpelling() const;
7048
7049
7050 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLGenericAddressSpace; }
7051};
7052
7053class OpenCLGlobalAddressSpaceAttr : public TypeAttr {
7054public:
7055 static OpenCLGlobalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7056 auto *A = new (Ctx) OpenCLGlobalAddressSpaceAttr(Loc, Ctx, 0);
7057 A->setImplicit(true);
7058 return A;
7059 }
7060
7061 OpenCLGlobalAddressSpaceAttr(SourceRange R, ASTContext &Ctx
7062 , unsigned SI
7063 )
7064 : TypeAttr(attr::OpenCLGlobalAddressSpace, R, SI, false)
7065 {
7066 }
7067
7068 OpenCLGlobalAddressSpaceAttr *clone(ASTContext &C) const;
7069 void printPretty(raw_ostream &OS,
7070 const PrintingPolicy &Policy) const;
7071 const char *getSpelling() const;
7072
7073
7074 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLGlobalAddressSpace; }
7075};
7076
7077class OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
7078unsigned subGroupSize;
7079
7080public:
7081 static OpenCLIntelReqdSubGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned SubGroupSize, SourceRange Loc = SourceRange()) {
7082 auto *A = new (Ctx) OpenCLIntelReqdSubGroupSizeAttr(Loc, Ctx, SubGroupSize, 0);
7083 A->setImplicit(true);
7084 return A;
7085 }
7086
7087 OpenCLIntelReqdSubGroupSizeAttr(SourceRange R, ASTContext &Ctx
7088 , unsigned SubGroupSize
7089 , unsigned SI
7090 )
7091 : InheritableAttr(attr::OpenCLIntelReqdSubGroupSize, R, SI, false, false)
7092 , subGroupSize(SubGroupSize)
7093 {
7094 }
7095
7096 OpenCLIntelReqdSubGroupSizeAttr *clone(ASTContext &C) const;
7097 void printPretty(raw_ostream &OS,
7098 const PrintingPolicy &Policy) const;
7099 const char *getSpelling() const;
7100 unsigned getSubGroupSize() const {
7101 return subGroupSize;
7102 }
7103
7104
7105
7106 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLIntelReqdSubGroupSize; }
7107};
7108
7109class OpenCLKernelAttr : public InheritableAttr {
7110public:
7111 static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7112 auto *A = new (Ctx) OpenCLKernelAttr(Loc, Ctx, 0);
7113 A->setImplicit(true);
7114 return A;
7115 }
7116
7117 OpenCLKernelAttr(SourceRange R, ASTContext &Ctx
7118 , unsigned SI
7119 )
7120 : InheritableAttr(attr::OpenCLKernel, R, SI, false, false)
7121 {
7122 }
7123
7124 OpenCLKernelAttr *clone(ASTContext &C) const;
7125 void printPretty(raw_ostream &OS,
7126 const PrintingPolicy &Policy) const;
7127 const char *getSpelling() const;
7128
7129
7130 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLKernel; }
7131};
7132
7133class OpenCLLocalAddressSpaceAttr : public TypeAttr {
7134public:
7135 static OpenCLLocalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7136 auto *A = new (Ctx) OpenCLLocalAddressSpaceAttr(Loc, Ctx, 0);
7137 A->setImplicit(true);
7138 return A;
7139 }
7140
7141 OpenCLLocalAddressSpaceAttr(SourceRange R, ASTContext &Ctx
7142 , unsigned SI
7143 )
7144 : TypeAttr(attr::OpenCLLocalAddressSpace, R, SI, false)
7145 {
7146 }
7147
7148 OpenCLLocalAddressSpaceAttr *clone(ASTContext &C) const;
7149 void printPretty(raw_ostream &OS,
7150 const PrintingPolicy &Policy) const;
7151 const char *getSpelling() const;
7152
7153
7154 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLLocalAddressSpace; }
7155};
7156
7157class OpenCLPrivateAddressSpaceAttr : public TypeAttr {
7158public:
7159 static OpenCLPrivateAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7160 auto *A = new (Ctx) OpenCLPrivateAddressSpaceAttr(Loc, Ctx, 0);
7161 A->setImplicit(true);
7162 return A;
7163 }
7164
7165 OpenCLPrivateAddressSpaceAttr(SourceRange R, ASTContext &Ctx
7166 , unsigned SI
7167 )
7168 : TypeAttr(attr::OpenCLPrivateAddressSpace, R, SI, false)
7169 {
7170 }
7171
7172 OpenCLPrivateAddressSpaceAttr *clone(ASTContext &C) const;
7173 void printPretty(raw_ostream &OS,
7174 const PrintingPolicy &Policy) const;
7175 const char *getSpelling() const;
7176
7177
7178 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLPrivateAddressSpace; }
7179};
7180
7181class OpenCLUnrollHintAttr : public InheritableAttr {
7182unsigned unrollHint;
7183
7184public:
7185 static OpenCLUnrollHintAttr *CreateImplicit(ASTContext &Ctx, unsigned UnrollHint, SourceRange Loc = SourceRange()) {
7186 auto *A = new (Ctx) OpenCLUnrollHintAttr(Loc, Ctx, UnrollHint, 0);
7187 A->setImplicit(true);
7188 return A;
7189 }
7190
7191 OpenCLUnrollHintAttr(SourceRange R, ASTContext &Ctx
7192 , unsigned UnrollHint
7193 , unsigned SI
7194 )
7195 : InheritableAttr(attr::OpenCLUnrollHint, R, SI, false, false)
7196 , unrollHint(UnrollHint)
7197 {
7198 }
7199
7200 OpenCLUnrollHintAttr *clone(ASTContext &C) const;
7201 void printPretty(raw_ostream &OS,
7202 const PrintingPolicy &Policy) const;
7203 const char *getSpelling() const;
7204 unsigned getUnrollHint() const {
7205 return unrollHint;
7206 }
7207
7208
7209
7210 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLUnrollHint; }
7211};
7212
7213class OptimizeNoneAttr : public InheritableAttr {
7214public:
7215 static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7216 auto *A = new (Ctx) OptimizeNoneAttr(Loc, Ctx, 0);
7217 A->setImplicit(true);
7218 return A;
7219 }
7220
7221 OptimizeNoneAttr(SourceRange R, ASTContext &Ctx
7222 , unsigned SI
7223 )
7224 : InheritableAttr(attr::OptimizeNone, R, SI, false, false)
7225 {
7226 }
7227
7228 OptimizeNoneAttr *clone(ASTContext &C) const;
7229 void printPretty(raw_ostream &OS,
7230 const PrintingPolicy &Policy) const;
7231 const char *getSpelling() const;
7232
7233
7234 static bool classof(const Attr *A) { return A->getKind() == attr::OptimizeNone; }
7235};
7236
7237class OverloadableAttr : public Attr {
7238public:
7239 static OverloadableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7240 auto *A = new (Ctx) OverloadableAttr(Loc, Ctx, 0);
7241 A->setImplicit(true);
7242 return A;
7243 }
7244
7245 OverloadableAttr(SourceRange R, ASTContext &Ctx
7246 , unsigned SI
7247 )
7248 : Attr(attr::Overloadable, R, SI, false)
7249 {
7250 }
7251
7252 OverloadableAttr *clone(ASTContext &C) const;
7253 void printPretty(raw_ostream &OS,
7254 const PrintingPolicy &Policy) const;
7255 const char *getSpelling() const;
7256
7257
7258 static bool classof(const Attr *A) { return A->getKind() == attr::Overloadable; }
7259};
7260
7261class OverrideAttr : public InheritableAttr {
7262public:
7263 static OverrideAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7264 auto *A = new (Ctx) OverrideAttr(Loc, Ctx, 0);
7265 A->setImplicit(true);
7266 return A;
7267 }
7268
7269 OverrideAttr(SourceRange R, ASTContext &Ctx
7270 , unsigned SI
7271 )
7272 : InheritableAttr(attr::Override, R, SI, false, false)
7273 {
7274 }
7275
7276 OverrideAttr *clone(ASTContext &C) const;
7277 void printPretty(raw_ostream &OS,
7278 const PrintingPolicy &Policy) const;
7279 const char *getSpelling() const;
7280
7281
7282 static bool classof(const Attr *A) { return A->getKind() == attr::Override; }
7283};
7284
7285class OwnershipAttr : public InheritableAttr {
7286IdentifierInfo * module;
7287
7288 unsigned args_Size;
7289 ParamIdx *args_;
7290
7291public:
7292 enum Spelling {
7293 GNU_ownership_holds = 0,
7294 CXX11_clang_ownership_holds = 1,
7295 C2x_clang_ownership_holds = 2,
7296 GNU_ownership_returns = 3,
7297 CXX11_clang_ownership_returns = 4,
7298 C2x_clang_ownership_returns = 5,
7299 GNU_ownership_takes = 6,
7300 CXX11_clang_ownership_takes = 7,
7301 C2x_clang_ownership_takes = 8
7302 };
7303
7304 static OwnershipAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * Module, ParamIdx *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
7305 auto *A = new (Ctx) OwnershipAttr(Loc, Ctx, Module, Args, ArgsSize, S);
7306 A->setImplicit(true);
7307 return A;
7308 }
7309
7310 OwnershipAttr(SourceRange R, ASTContext &Ctx
7311 , IdentifierInfo * Module
7312 , ParamIdx *Args, unsigned ArgsSize
7313 , unsigned SI
7314 )
7315 : InheritableAttr(attr::Ownership, R, SI, false, false)
7316 , module(Module)
7317 , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[args_Size])
7318 {
7319 std::copy(Args, Args + args_Size, args_);
7320 }
7321
7322 OwnershipAttr(SourceRange R, ASTContext &Ctx
7323 , IdentifierInfo * Module
7324 , unsigned SI
7325 )
7326 : InheritableAttr(attr::Ownership, R, SI, false, false)
7327 , module(Module)
7328 , args_Size(0), args_(nullptr)
7329 {
7330 }
7331
7332 OwnershipAttr *clone(ASTContext &C) const;
7333 void printPretty(raw_ostream &OS,
7334 const PrintingPolicy &Policy) const;
7335 const char *getSpelling() const;
7336 Spelling getSemanticSpelling() const {
7337 switch (SpellingListIndex) {
7338 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7338)
;
7339 case 0: return GNU_ownership_holds;
7340 case 1: return CXX11_clang_ownership_holds;
7341 case 2: return C2x_clang_ownership_holds;
7342 case 3: return GNU_ownership_returns;
7343 case 4: return CXX11_clang_ownership_returns;
7344 case 5: return C2x_clang_ownership_returns;
7345 case 6: return GNU_ownership_takes;
7346 case 7: return CXX11_clang_ownership_takes;
7347 case 8: return C2x_clang_ownership_takes;
7348 }
7349 }
7350 bool isHolds() const { return SpellingListIndex == 0 ||
7351 SpellingListIndex == 1 ||
7352 SpellingListIndex == 2; }
7353 bool isReturns() const { return SpellingListIndex == 3 ||
7354 SpellingListIndex == 4 ||
7355 SpellingListIndex == 5; }
7356 bool isTakes() const { return SpellingListIndex == 6 ||
7357 SpellingListIndex == 7 ||
7358 SpellingListIndex == 8; }
7359 IdentifierInfo * getModule() const {
7360 return module;
7361 }
7362
7363 typedef ParamIdx* args_iterator;
7364 args_iterator args_begin() const { return args_; }
7365 args_iterator args_end() const { return args_ + args_Size; }
7366 unsigned args_size() const { return args_Size; }
7367 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
7368
7369
7370
7371 enum OwnershipKind { Holds, Returns, Takes };
7372 OwnershipKind getOwnKind() const {
7373 return isHolds() ? Holds :
7374 isTakes() ? Takes :
7375 Returns;
7376 }
7377
7378
7379 static bool classof(const Attr *A) { return A->getKind() == attr::Ownership; }
7380};
7381
7382class PackedAttr : public InheritableAttr {
7383public:
7384 static PackedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7385 auto *A = new (Ctx) PackedAttr(Loc, Ctx, 0);
7386 A->setImplicit(true);
7387 return A;
7388 }
7389
7390 PackedAttr(SourceRange R, ASTContext &Ctx
7391 , unsigned SI
7392 )
7393 : InheritableAttr(attr::Packed, R, SI, false, false)
7394 {
7395 }
7396
7397 PackedAttr *clone(ASTContext &C) const;
7398 void printPretty(raw_ostream &OS,
7399 const PrintingPolicy &Policy) const;
7400 const char *getSpelling() const;
7401
7402
7403 static bool classof(const Attr *A) { return A->getKind() == attr::Packed; }
7404};
7405
7406class ParamTypestateAttr : public InheritableAttr {
7407public:
7408 enum ConsumedState {
7409 Unknown,
7410 Consumed,
7411 Unconsumed
7412 };
7413private:
7414 ConsumedState paramState;
7415
7416public:
7417 static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState ParamState, SourceRange Loc = SourceRange()) {
7418 auto *A = new (Ctx) ParamTypestateAttr(Loc, Ctx, ParamState, 0);
7419 A->setImplicit(true);
7420 return A;
7421 }
7422
7423 ParamTypestateAttr(SourceRange R, ASTContext &Ctx
7424 , ConsumedState ParamState
7425 , unsigned SI
7426 )
7427 : InheritableAttr(attr::ParamTypestate, R, SI, false, false)
7428 , paramState(ParamState)
7429 {
7430 }
7431
7432 ParamTypestateAttr *clone(ASTContext &C) const;
7433 void printPretty(raw_ostream &OS,
7434 const PrintingPolicy &Policy) const;
7435 const char *getSpelling() const;
7436 ConsumedState getParamState() const {
7437 return paramState;
7438 }
7439
7440 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
7441 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
7442 .Case("unknown", ParamTypestateAttr::Unknown)
7443 .Case("consumed", ParamTypestateAttr::Consumed)
7444 .Case("unconsumed", ParamTypestateAttr::Unconsumed)
7445 .Default(Optional<ConsumedState>());
7446 if (R) {
7447 Out = *R;
7448 return true;
7449 }
7450 return false;
7451 }
7452
7453 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
7454 switch(Val) {
7455 case ParamTypestateAttr::Unknown: return "unknown";
7456 case ParamTypestateAttr::Consumed: return "consumed";
7457 case ParamTypestateAttr::Unconsumed: return "unconsumed";
7458 }
7459 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7459)
;
7460 }
7461
7462
7463 static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; }
7464};
7465
7466class PascalAttr : public InheritableAttr {
7467public:
7468 static PascalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7469 auto *A = new (Ctx) PascalAttr(Loc, Ctx, 0);
7470 A->setImplicit(true);
7471 return A;
7472 }
7473
7474 PascalAttr(SourceRange R, ASTContext &Ctx
7475 , unsigned SI
7476 )
7477 : InheritableAttr(attr::Pascal, R, SI, false, false)
7478 {
7479 }
7480
7481 PascalAttr *clone(ASTContext &C) const;
7482 void printPretty(raw_ostream &OS,
7483 const PrintingPolicy &Policy) const;
7484 const char *getSpelling() const;
7485
7486
7487 static bool classof(const Attr *A) { return A->getKind() == attr::Pascal; }
7488};
7489
7490class PassObjectSizeAttr : public InheritableParamAttr {
7491int type;
7492
7493public:
7494 enum Spelling {
7495 GNU_pass_object_size = 0,
7496 CXX11_clang_pass_object_size = 1,
7497 C2x_clang_pass_object_size = 2,
7498 GNU_pass_dynamic_object_size = 3,
7499 CXX11_clang_pass_dynamic_object_size = 4,
7500 C2x_clang_pass_dynamic_object_size = 5
7501 };
7502
7503 static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, Spelling S, int Type, SourceRange Loc = SourceRange()) {
7504 auto *A = new (Ctx) PassObjectSizeAttr(Loc, Ctx, Type, S);
7505 A->setImplicit(true);
7506 return A;
7507 }
7508
7509 PassObjectSizeAttr(SourceRange R, ASTContext &Ctx
7510 , int Type
7511 , unsigned SI
7512 )
7513 : InheritableParamAttr(attr::PassObjectSize, R, SI, false, false)
7514 , type(Type)
7515 {
7516 }
7517
7518 PassObjectSizeAttr *clone(ASTContext &C) const;
7519 void printPretty(raw_ostream &OS,
7520 const PrintingPolicy &Policy) const;
7521 const char *getSpelling() const;
7522 Spelling getSemanticSpelling() const {
7523 switch (SpellingListIndex) {
7524 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7524)
;
7525 case 0: return GNU_pass_object_size;
7526 case 1: return CXX11_clang_pass_object_size;
7527 case 2: return C2x_clang_pass_object_size;
7528 case 3: return GNU_pass_dynamic_object_size;
7529 case 4: return CXX11_clang_pass_dynamic_object_size;
7530 case 5: return C2x_clang_pass_dynamic_object_size;
7531 }
7532 }
7533 bool isDynamic() const { return SpellingListIndex == 3 ||
7534 SpellingListIndex == 4 ||
7535 SpellingListIndex == 5; }
7536 int getType() const {
7537 return type;
7538 }
7539
7540
7541
7542 static bool classof(const Attr *A) { return A->getKind() == attr::PassObjectSize; }
7543};
7544
7545class PcsAttr : public InheritableAttr {
7546public:
7547 enum PCSType {
7548 AAPCS,
7549 AAPCS_VFP
7550 };
7551private:
7552 PCSType pCS;
7553
7554public:
7555 static PcsAttr *CreateImplicit(ASTContext &Ctx, PCSType PCS, SourceRange Loc = SourceRange()) {
7556 auto *A = new (Ctx) PcsAttr(Loc, Ctx, PCS, 0);
7557 A->setImplicit(true);
7558 return A;
7559 }
7560
7561 PcsAttr(SourceRange R, ASTContext &Ctx
7562 , PCSType PCS
7563 , unsigned SI
7564 )
7565 : InheritableAttr(attr::Pcs, R, SI, false, false)
7566 , pCS(PCS)
7567 {
7568 }
7569
7570 PcsAttr *clone(ASTContext &C) const;
7571 void printPretty(raw_ostream &OS,
7572 const PrintingPolicy &Policy) const;
7573 const char *getSpelling() const;
7574 PCSType getPCS() const {
7575 return pCS;
7576 }
7577
7578 static bool ConvertStrToPCSType(StringRef Val, PCSType &Out) {
7579 Optional<PCSType> R = llvm::StringSwitch<Optional<PCSType>>(Val)
7580 .Case("aapcs", PcsAttr::AAPCS)
7581 .Case("aapcs-vfp", PcsAttr::AAPCS_VFP)
7582 .Default(Optional<PCSType>());
7583 if (R) {
7584 Out = *R;
7585 return true;
7586 }
7587 return false;
7588 }
7589
7590 static const char *ConvertPCSTypeToStr(PCSType Val) {
7591 switch(Val) {
7592 case PcsAttr::AAPCS: return "aapcs";
7593 case PcsAttr::AAPCS_VFP: return "aapcs-vfp";
7594 }
7595 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7595)
;
7596 }
7597
7598
7599 static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; }
7600};
7601
7602class PragmaClangBSSSectionAttr : public InheritableAttr {
7603unsigned nameLength;
7604char *name;
7605
7606public:
7607 static PragmaClangBSSSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
7608 auto *A = new (Ctx) PragmaClangBSSSectionAttr(Loc, Ctx, Name, 0);
7609 A->setImplicit(true);
7610 return A;
7611 }
7612
7613 PragmaClangBSSSectionAttr(SourceRange R, ASTContext &Ctx
7614 , llvm::StringRef Name
7615 , unsigned SI
7616 )
7617 : InheritableAttr(attr::PragmaClangBSSSection, R, SI, false, false)
7618 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
7619 {
7620 if (!Name.empty())
7621 std::memcpy(name, Name.data(), nameLength);
7622 }
7623
7624 PragmaClangBSSSectionAttr *clone(ASTContext &C) const;
7625 void printPretty(raw_ostream &OS,
7626 const PrintingPolicy &Policy) const;
7627 const char *getSpelling() const;
7628 llvm::StringRef getName() const {
7629 return llvm::StringRef(name, nameLength);
7630 }
7631 unsigned getNameLength() const {
7632 return nameLength;
7633 }
7634 void setName(ASTContext &C, llvm::StringRef S) {
7635 nameLength = S.size();
7636 this->name = new (C, 1) char [nameLength];
7637 if (!S.empty())
7638 std::memcpy(this->name, S.data(), nameLength);
7639 }
7640
7641
7642
7643 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangBSSSection; }
7644};
7645
7646class PragmaClangDataSectionAttr : public InheritableAttr {
7647unsigned nameLength;
7648char *name;
7649
7650public:
7651 static PragmaClangDataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
7652 auto *A = new (Ctx) PragmaClangDataSectionAttr(Loc, Ctx, Name, 0);
7653 A->setImplicit(true);
7654 return A;
7655 }
7656
7657 PragmaClangDataSectionAttr(SourceRange R, ASTContext &Ctx
7658 , llvm::StringRef Name
7659 , unsigned SI
7660 )
7661 : InheritableAttr(attr::PragmaClangDataSection, R, SI, false, false)
7662 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
7663 {
7664 if (!Name.empty())
7665 std::memcpy(name, Name.data(), nameLength);
7666 }
7667
7668 PragmaClangDataSectionAttr *clone(ASTContext &C) const;
7669 void printPretty(raw_ostream &OS,
7670 const PrintingPolicy &Policy) const;
7671 const char *getSpelling() const;
7672 llvm::StringRef getName() const {
7673 return llvm::StringRef(name, nameLength);
7674 }
7675 unsigned getNameLength() const {
7676 return nameLength;
7677 }
7678 void setName(ASTContext &C, llvm::StringRef S) {
7679 nameLength = S.size();
7680 this->name = new (C, 1) char [nameLength];
7681 if (!S.empty())
7682 std::memcpy(this->name, S.data(), nameLength);
7683 }
7684
7685
7686
7687 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangDataSection; }
7688};
7689
7690class PragmaClangRodataSectionAttr : public InheritableAttr {
7691unsigned nameLength;
7692char *name;
7693
7694public:
7695 static PragmaClangRodataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
7696 auto *A = new (Ctx) PragmaClangRodataSectionAttr(Loc, Ctx, Name, 0);
7697 A->setImplicit(true);
7698 return A;
7699 }
7700
7701 PragmaClangRodataSectionAttr(SourceRange R, ASTContext &Ctx
7702 , llvm::StringRef Name
7703 , unsigned SI
7704 )
7705 : InheritableAttr(attr::PragmaClangRodataSection, R, SI, false, false)
7706 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
7707 {
7708 if (!Name.empty())
7709 std::memcpy(name, Name.data(), nameLength);
7710 }
7711
7712 PragmaClangRodataSectionAttr *clone(ASTContext &C) const;
7713 void printPretty(raw_ostream &OS,
7714 const PrintingPolicy &Policy) const;
7715 const char *getSpelling() const;
7716 llvm::StringRef getName() const {
7717 return llvm::StringRef(name, nameLength);
7718 }
7719 unsigned getNameLength() const {
7720 return nameLength;
7721 }
7722 void setName(ASTContext &C, llvm::StringRef S) {
7723 nameLength = S.size();
7724 this->name = new (C, 1) char [nameLength];
7725 if (!S.empty())
7726 std::memcpy(this->name, S.data(), nameLength);
7727 }
7728
7729
7730
7731 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangRodataSection; }
7732};
7733
7734class PragmaClangTextSectionAttr : public InheritableAttr {
7735unsigned nameLength;
7736char *name;
7737
7738public:
7739 static PragmaClangTextSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
7740 auto *A = new (Ctx) PragmaClangTextSectionAttr(Loc, Ctx, Name, 0);
7741 A->setImplicit(true);
7742 return A;
7743 }
7744
7745 PragmaClangTextSectionAttr(SourceRange R, ASTContext &Ctx
7746 , llvm::StringRef Name
7747 , unsigned SI
7748 )
7749 : InheritableAttr(attr::PragmaClangTextSection, R, SI, false, false)
7750 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
7751 {
7752 if (!Name.empty())
7753 std::memcpy(name, Name.data(), nameLength);
7754 }
7755
7756 PragmaClangTextSectionAttr *clone(ASTContext &C) const;
7757 void printPretty(raw_ostream &OS,
7758 const PrintingPolicy &Policy) const;
7759 const char *getSpelling() const;
7760 llvm::StringRef getName() const {
7761 return llvm::StringRef(name, nameLength);
7762 }
7763 unsigned getNameLength() const {
7764 return nameLength;
7765 }
7766 void setName(ASTContext &C, llvm::StringRef S) {
7767 nameLength = S.size();
7768 this->name = new (C, 1) char [nameLength];
7769 if (!S.empty())
7770 std::memcpy(this->name, S.data(), nameLength);
7771 }
7772
7773
7774
7775 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangTextSection; }
7776};
7777
7778class PreserveAllAttr : public InheritableAttr {
7779public:
7780 static PreserveAllAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7781 auto *A = new (Ctx) PreserveAllAttr(Loc, Ctx, 0);
7782 A->setImplicit(true);
7783 return A;
7784 }
7785
7786 PreserveAllAttr(SourceRange R, ASTContext &Ctx
7787 , unsigned SI
7788 )
7789 : InheritableAttr(attr::PreserveAll, R, SI, false, false)
7790 {
7791 }
7792
7793 PreserveAllAttr *clone(ASTContext &C) const;
7794 void printPretty(raw_ostream &OS,
7795 const PrintingPolicy &Policy) const;
7796 const char *getSpelling() const;
7797
7798
7799 static bool classof(const Attr *A) { return A->getKind() == attr::PreserveAll; }
7800};
7801
7802class PreserveMostAttr : public InheritableAttr {
7803public:
7804 static PreserveMostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7805 auto *A = new (Ctx) PreserveMostAttr(Loc, Ctx, 0);
7806 A->setImplicit(true);
7807 return A;
7808 }
7809
7810 PreserveMostAttr(SourceRange R, ASTContext &Ctx
7811 , unsigned SI
7812 )
7813 : InheritableAttr(attr::PreserveMost, R, SI, false, false)
7814 {
7815 }
7816
7817 PreserveMostAttr *clone(ASTContext &C) const;
7818 void printPretty(raw_ostream &OS,
7819 const PrintingPolicy &Policy) const;
7820 const char *getSpelling() const;
7821
7822
7823 static bool classof(const Attr *A) { return A->getKind() == attr::PreserveMost; }
7824};
7825
7826class PtGuardedByAttr : public InheritableAttr {
7827Expr * arg;
7828
7829public:
7830 static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
7831 auto *A = new (Ctx) PtGuardedByAttr(Loc, Ctx, Arg, 0);
7832 A->setImplicit(true);
7833 return A;
7834 }
7835
7836 PtGuardedByAttr(SourceRange R, ASTContext &Ctx
7837 , Expr * Arg
7838 , unsigned SI
7839 )
7840 : InheritableAttr(attr::PtGuardedBy, R, SI, true, true)
7841 , arg(Arg)
7842 {
7843 }
7844
7845 PtGuardedByAttr *clone(ASTContext &C) const;
7846 void printPretty(raw_ostream &OS,
7847 const PrintingPolicy &Policy) const;
7848 const char *getSpelling() const;
7849 Expr * getArg() const {
7850 return arg;
7851 }
7852
7853
7854
7855 static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedBy; }
7856};
7857
7858class PtGuardedVarAttr : public InheritableAttr {
7859public:
7860 static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7861 auto *A = new (Ctx) PtGuardedVarAttr(Loc, Ctx, 0);
7862 A->setImplicit(true);
7863 return A;
7864 }
7865
7866 PtGuardedVarAttr(SourceRange R, ASTContext &Ctx
7867 , unsigned SI
7868 )
7869 : InheritableAttr(attr::PtGuardedVar, R, SI, false, false)
7870 {
7871 }
7872
7873 PtGuardedVarAttr *clone(ASTContext &C) const;
7874 void printPretty(raw_ostream &OS,
7875 const PrintingPolicy &Policy) const;
7876 const char *getSpelling() const;
7877
7878
7879 static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedVar; }
7880};
7881
7882class Ptr32Attr : public TypeAttr {
7883public:
7884 static Ptr32Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7885 auto *A = new (Ctx) Ptr32Attr(Loc, Ctx, 0);
7886 A->setImplicit(true);
7887 return A;
7888 }
7889
7890 Ptr32Attr(SourceRange R, ASTContext &Ctx
7891 , unsigned SI
7892 )
7893 : TypeAttr(attr::Ptr32, R, SI, false)
7894 {
7895 }
7896
7897 Ptr32Attr *clone(ASTContext &C) const;
7898 void printPretty(raw_ostream &OS,
7899 const PrintingPolicy &Policy) const;
7900 const char *getSpelling() const;
7901
7902
7903 static bool classof(const Attr *A) { return A->getKind() == attr::Ptr32; }
7904};
7905
7906class Ptr64Attr : public TypeAttr {
7907public:
7908 static Ptr64Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7909 auto *A = new (Ctx) Ptr64Attr(Loc, Ctx, 0);
7910 A->setImplicit(true);
7911 return A;
7912 }
7913
7914 Ptr64Attr(SourceRange R, ASTContext &Ctx
7915 , unsigned SI
7916 )
7917 : TypeAttr(attr::Ptr64, R, SI, false)
7918 {
7919 }
7920
7921 Ptr64Attr *clone(ASTContext &C) const;
7922 void printPretty(raw_ostream &OS,
7923 const PrintingPolicy &Policy) const;
7924 const char *getSpelling() const;
7925
7926
7927 static bool classof(const Attr *A) { return A->getKind() == attr::Ptr64; }
7928};
7929
7930class PureAttr : public InheritableAttr {
7931public:
7932 static PureAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
7933 auto *A = new (Ctx) PureAttr(Loc, Ctx, 0);
7934 A->setImplicit(true);
7935 return A;
7936 }
7937
7938 PureAttr(SourceRange R, ASTContext &Ctx
7939 , unsigned SI
7940 )
7941 : InheritableAttr(attr::Pure, R, SI, false, false)
7942 {
7943 }
7944
7945 PureAttr *clone(ASTContext &C) const;
7946 void printPretty(raw_ostream &OS,
7947 const PrintingPolicy &Policy) const;
7948 const char *getSpelling() const;
7949
7950
7951 static bool classof(const Attr *A) { return A->getKind() == attr::Pure; }
7952};
7953
7954class RISCVInterruptAttr : public InheritableAttr {
7955public:
7956 enum InterruptType {
7957 user,
7958 supervisor,
7959 machine
7960 };
7961private:
7962 InterruptType interrupt;
7963
7964public:
7965 static RISCVInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
7966 auto *A = new (Ctx) RISCVInterruptAttr(Loc, Ctx, Interrupt, 0);
7967 A->setImplicit(true);
7968 return A;
7969 }
7970
7971 RISCVInterruptAttr(SourceRange R, ASTContext &Ctx
7972 , InterruptType Interrupt
7973 , unsigned SI
7974 )
7975 : InheritableAttr(attr::RISCVInterrupt, R, SI, false, false)
7976 , interrupt(Interrupt)
7977 {
7978 }
7979
7980 RISCVInterruptAttr(SourceRange R, ASTContext &Ctx
7981 , unsigned SI
7982 )
7983 : InheritableAttr(attr::RISCVInterrupt, R, SI, false, false)
7984 , interrupt(InterruptType(0))
7985 {
7986 }
7987
7988 RISCVInterruptAttr *clone(ASTContext &C) const;
7989 void printPretty(raw_ostream &OS,
7990 const PrintingPolicy &Policy) const;
7991 const char *getSpelling() const;
7992 InterruptType getInterrupt() const {
7993 return interrupt;
7994 }
7995
7996 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
7997 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
7998 .Case("user", RISCVInterruptAttr::user)
7999 .Case("supervisor", RISCVInterruptAttr::supervisor)
8000 .Case("machine", RISCVInterruptAttr::machine)
8001 .Default(Optional<InterruptType>());
8002 if (R) {
8003 Out = *R;
8004 return true;
8005 }
8006 return false;
8007 }
8008
8009 static const char *ConvertInterruptTypeToStr(InterruptType Val) {
8010 switch(Val) {
8011 case RISCVInterruptAttr::user: return "user";
8012 case RISCVInterruptAttr::supervisor: return "supervisor";
8013 case RISCVInterruptAttr::machine: return "machine";
8014 }
8015 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8015)
;
8016 }
8017
8018
8019 static bool classof(const Attr *A) { return A->getKind() == attr::RISCVInterrupt; }
8020};
8021
8022class RegCallAttr : public InheritableAttr {
8023public:
8024 static RegCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8025 auto *A = new (Ctx) RegCallAttr(Loc, Ctx, 0);
8026 A->setImplicit(true);
8027 return A;
8028 }
8029
8030 RegCallAttr(SourceRange R, ASTContext &Ctx
8031 , unsigned SI
8032 )
8033 : InheritableAttr(attr::RegCall, R, SI, false, false)
8034 {
8035 }
8036
8037 RegCallAttr *clone(ASTContext &C) const;
8038 void printPretty(raw_ostream &OS,
8039 const PrintingPolicy &Policy) const;
8040 const char *getSpelling() const;
8041
8042
8043 static bool classof(const Attr *A) { return A->getKind() == attr::RegCall; }
8044};
8045
8046class ReinitializesAttr : public InheritableAttr {
8047public:
8048 static ReinitializesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8049 auto *A = new (Ctx) ReinitializesAttr(Loc, Ctx, 0);
8050 A->setImplicit(true);
8051 return A;
8052 }
8053
8054 ReinitializesAttr(SourceRange R, ASTContext &Ctx
8055 , unsigned SI
8056 )
8057 : InheritableAttr(attr::Reinitializes, R, SI, false, false)
8058 {
8059 }
8060
8061 ReinitializesAttr *clone(ASTContext &C) const;
8062 void printPretty(raw_ostream &OS,
8063 const PrintingPolicy &Policy) const;
8064 const char *getSpelling() const;
8065
8066
8067 static bool classof(const Attr *A) { return A->getKind() == attr::Reinitializes; }
8068};
8069
8070class ReleaseCapabilityAttr : public InheritableAttr {
8071 unsigned args_Size;
8072 Expr * *args_;
8073
8074public:
8075 enum Spelling {
8076 GNU_release_capability = 0,
8077 CXX11_clang_release_capability = 1,
8078 GNU_release_shared_capability = 2,
8079 CXX11_clang_release_shared_capability = 3,
8080 GNU_release_generic_capability = 4,
8081 CXX11_clang_release_generic_capability = 5,
8082 GNU_unlock_function = 6,
8083 CXX11_clang_unlock_function = 7
8084 };
8085
8086 static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
8087 auto *A = new (Ctx) ReleaseCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
8088 A->setImplicit(true);
8089 return A;
8090 }
8091
8092 ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
8093 , Expr * *Args, unsigned ArgsSize
8094 , unsigned SI
8095 )
8096 : InheritableAttr(attr::ReleaseCapability, R, SI, true, true)
8097 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
8098 {
8099 std::copy(Args, Args + args_Size, args_);
8100 }
8101
8102 ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
8103 , unsigned SI
8104 )
8105 : InheritableAttr(attr::ReleaseCapability, R, SI, true, true)
8106 , args_Size(0), args_(nullptr)
8107 {
8108 }
8109
8110 ReleaseCapabilityAttr *clone(ASTContext &C) const;
8111 void printPretty(raw_ostream &OS,
8112 const PrintingPolicy &Policy) const;
8113 const char *getSpelling() const;
8114 Spelling getSemanticSpelling() const {
8115 switch (SpellingListIndex) {
8116 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8116)
;
8117 case 0: return GNU_release_capability;
8118 case 1: return CXX11_clang_release_capability;
8119 case 2: return GNU_release_shared_capability;
8120 case 3: return CXX11_clang_release_shared_capability;
8121 case 4: return GNU_release_generic_capability;
8122 case 5: return CXX11_clang_release_generic_capability;
8123 case 6: return GNU_unlock_function;
8124 case 7: return CXX11_clang_unlock_function;
8125 }
8126 }
8127 bool isShared() const { return SpellingListIndex == 2 ||
8128 SpellingListIndex == 3; }
8129 bool isGeneric() const { return SpellingListIndex == 4 ||
8130 SpellingListIndex == 5 ||
8131 SpellingListIndex == 6 ||
8132 SpellingListIndex == 7; }
8133 typedef Expr ** args_iterator;
8134 args_iterator args_begin() const { return args_; }
8135 args_iterator args_end() const { return args_ + args_Size; }
8136 unsigned args_size() const { return args_Size; }
8137 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
8138
8139
8140
8141
8142 static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseCapability; }
8143};
8144
8145class RenderScriptKernelAttr : public Attr {
8146public:
8147 static RenderScriptKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8148 auto *A = new (Ctx) RenderScriptKernelAttr(Loc, Ctx, 0);
8149 A->setImplicit(true);
8150 return A;
8151 }
8152
8153 RenderScriptKernelAttr(SourceRange R, ASTContext &Ctx
8154 , unsigned SI
8155 )
8156 : Attr(attr::RenderScriptKernel, R, SI, false)
8157 {
8158 }
8159
8160 RenderScriptKernelAttr *clone(ASTContext &C) const;
8161 void printPretty(raw_ostream &OS,
8162 const PrintingPolicy &Policy) const;
8163 const char *getSpelling() const;
8164
8165
8166 static bool classof(const Attr *A) { return A->getKind() == attr::RenderScriptKernel; }
8167};
8168
8169class ReqdWorkGroupSizeAttr : public InheritableAttr {
8170unsigned xDim;
8171
8172unsigned yDim;
8173
8174unsigned zDim;
8175
8176public:
8177 static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
8178 auto *A = new (Ctx) ReqdWorkGroupSizeAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
8179 A->setImplicit(true);
8180 return A;
8181 }
8182
8183 ReqdWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
8184 , unsigned XDim
8185 , unsigned YDim
8186 , unsigned ZDim
8187 , unsigned SI
8188 )
8189 : InheritableAttr(attr::ReqdWorkGroupSize, R, SI, false, false)
8190 , xDim(XDim)
8191 , yDim(YDim)
8192 , zDim(ZDim)
8193 {
8194 }
8195
8196 ReqdWorkGroupSizeAttr *clone(ASTContext &C) const;
8197 void printPretty(raw_ostream &OS,
8198 const PrintingPolicy &Policy) const;
8199 const char *getSpelling() const;
8200 unsigned getXDim() const {
8201 return xDim;
8202 }
8203
8204 unsigned getYDim() const {
8205 return yDim;
8206 }
8207
8208 unsigned getZDim() const {
8209 return zDim;
8210 }
8211
8212
8213
8214 static bool classof(const Attr *A) { return A->getKind() == attr::ReqdWorkGroupSize; }
8215};
8216
8217class RequireConstantInitAttr : public InheritableAttr {
8218public:
8219 static RequireConstantInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8220 auto *A = new (Ctx) RequireConstantInitAttr(Loc, Ctx, 0);
8221 A->setImplicit(true);
8222 return A;
8223 }
8224
8225 RequireConstantInitAttr(SourceRange R, ASTContext &Ctx
8226 , unsigned SI
8227 )
8228 : InheritableAttr(attr::RequireConstantInit, R, SI, false, false)
8229 {
8230 }
8231
8232 RequireConstantInitAttr *clone(ASTContext &C) const;
8233 void printPretty(raw_ostream &OS,
8234 const PrintingPolicy &Policy) const;
8235 const char *getSpelling() const;
8236
8237
8238 static bool classof(const Attr *A) { return A->getKind() == attr::RequireConstantInit; }
8239};
8240
8241class RequiresCapabilityAttr : public InheritableAttr {
8242 unsigned args_Size;
8243 Expr * *args_;
8244
8245public:
8246 enum Spelling {
8247 GNU_requires_capability = 0,
8248 CXX11_clang_requires_capability = 1,
8249 GNU_exclusive_locks_required = 2,
8250 CXX11_clang_exclusive_locks_required = 3,
8251 GNU_requires_shared_capability = 4,
8252 CXX11_clang_requires_shared_capability = 5,
8253 GNU_shared_locks_required = 6,
8254 CXX11_clang_shared_locks_required = 7
8255 };
8256
8257 static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
8258 auto *A = new (Ctx) RequiresCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
8259 A->setImplicit(true);
8260 return A;
8261 }
8262
8263 RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
8264 , Expr * *Args, unsigned ArgsSize
8265 , unsigned SI
8266 )
8267 : InheritableAttr(attr::RequiresCapability, R, SI, true, true)
8268 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
8269 {
8270 std::copy(Args, Args + args_Size, args_);
8271 }
8272
8273 RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
8274 , unsigned SI
8275 )
8276 : InheritableAttr(attr::RequiresCapability, R, SI, true, true)
8277 , args_Size(0), args_(nullptr)
8278 {
8279 }
8280
8281 RequiresCapabilityAttr *clone(ASTContext &C) const;
8282 void printPretty(raw_ostream &OS,
8283 const PrintingPolicy &Policy) const;
8284 const char *getSpelling() const;
8285 Spelling getSemanticSpelling() const {
8286 switch (SpellingListIndex) {
8287 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8287)
;
8288 case 0: return GNU_requires_capability;
8289 case 1: return CXX11_clang_requires_capability;
8290 case 2: return GNU_exclusive_locks_required;
8291 case 3: return CXX11_clang_exclusive_locks_required;
8292 case 4: return GNU_requires_shared_capability;
8293 case 5: return CXX11_clang_requires_shared_capability;
8294 case 6: return GNU_shared_locks_required;
8295 case 7: return CXX11_clang_shared_locks_required;
8296 }
8297 }
8298 bool isShared() const { return SpellingListIndex == 4 ||
8299 SpellingListIndex == 5 ||
8300 SpellingListIndex == 6 ||
8301 SpellingListIndex == 7; }
8302 typedef Expr ** args_iterator;
8303 args_iterator args_begin() const { return args_; }
8304 args_iterator args_end() const { return args_ + args_Size; }
8305 unsigned args_size() const { return args_Size; }
8306 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
8307
8308
8309
8310
8311 static bool classof(const Attr *A) { return A->getKind() == attr::RequiresCapability; }
8312};
8313
8314class RestrictAttr : public InheritableAttr {
8315public:
8316 enum Spelling {
8317 Declspec_restrict = 0,
8318 GNU_malloc = 1,
8319 CXX11_gnu_malloc = 2
8320 };
8321
8322 static RestrictAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
8323 auto *A = new (Ctx) RestrictAttr(Loc, Ctx, S);
8324 A->setImplicit(true);
8325 return A;
8326 }
8327
8328 RestrictAttr(SourceRange R, ASTContext &Ctx
8329 , unsigned SI
8330 )
8331 : InheritableAttr(attr::Restrict, R, SI, false, false)
8332 {
8333 }
8334
8335 RestrictAttr *clone(ASTContext &C) const;
8336 void printPretty(raw_ostream &OS,
8337 const PrintingPolicy &Policy) const;
8338 const char *getSpelling() const;
8339 Spelling getSemanticSpelling() const {
8340 switch (SpellingListIndex) {
8341 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8341)
;
8342 case 0: return Declspec_restrict;
8343 case 1: return GNU_malloc;
8344 case 2: return CXX11_gnu_malloc;
8345 }
8346 }
8347
8348
8349 static bool classof(const Attr *A) { return A->getKind() == attr::Restrict; }
8350};
8351
8352class ReturnTypestateAttr : public InheritableAttr {
8353public:
8354 enum ConsumedState {
8355 Unknown,
8356 Consumed,
8357 Unconsumed
8358 };
8359private:
8360 ConsumedState state;
8361
8362public:
8363 static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState State, SourceRange Loc = SourceRange()) {
8364 auto *A = new (Ctx) ReturnTypestateAttr(Loc, Ctx, State, 0);
8365 A->setImplicit(true);
8366 return A;
8367 }
8368
8369 ReturnTypestateAttr(SourceRange R, ASTContext &Ctx
8370 , ConsumedState State
8371 , unsigned SI
8372 )
8373 : InheritableAttr(attr::ReturnTypestate, R, SI, false, false)
8374 , state(State)
8375 {
8376 }
8377
8378 ReturnTypestateAttr *clone(ASTContext &C) const;
8379 void printPretty(raw_ostream &OS,
8380 const PrintingPolicy &Policy) const;
8381 const char *getSpelling() const;
8382 ConsumedState getState() const {
8383 return state;
8384 }
8385
8386 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
8387 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
8388 .Case("unknown", ReturnTypestateAttr::Unknown)
8389 .Case("consumed", ReturnTypestateAttr::Consumed)
8390 .Case("unconsumed", ReturnTypestateAttr::Unconsumed)
8391 .Default(Optional<ConsumedState>());
8392 if (R) {
8393 Out = *R;
8394 return true;
8395 }
8396 return false;
8397 }
8398
8399 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
8400 switch(Val) {
8401 case ReturnTypestateAttr::Unknown: return "unknown";
8402 case ReturnTypestateAttr::Consumed: return "consumed";
8403 case ReturnTypestateAttr::Unconsumed: return "unconsumed";
8404 }
8405 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8405)
;
8406 }
8407
8408
8409 static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; }
8410};
8411
8412class ReturnsNonNullAttr : public InheritableAttr {
8413public:
8414 static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8415 auto *A = new (Ctx) ReturnsNonNullAttr(Loc, Ctx, 0);
8416 A->setImplicit(true);
8417 return A;
8418 }
8419
8420 ReturnsNonNullAttr(SourceRange R, ASTContext &Ctx
8421 , unsigned SI
8422 )
8423 : InheritableAttr(attr::ReturnsNonNull, R, SI, false, false)
8424 {
8425 }
8426
8427 ReturnsNonNullAttr *clone(ASTContext &C) const;
8428 void printPretty(raw_ostream &OS,
8429 const PrintingPolicy &Policy) const;
8430 const char *getSpelling() const;
8431
8432
8433 static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsNonNull; }
8434};
8435
8436class ReturnsTwiceAttr : public InheritableAttr {
8437public:
8438 static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8439 auto *A = new (Ctx) ReturnsTwiceAttr(Loc, Ctx, 0);
8440 A->setImplicit(true);
8441 return A;
8442 }
8443
8444 ReturnsTwiceAttr(SourceRange R, ASTContext &Ctx
8445 , unsigned SI
8446 )
8447 : InheritableAttr(attr::ReturnsTwice, R, SI, false, false)
8448 {
8449 }
8450
8451 ReturnsTwiceAttr *clone(ASTContext &C) const;
8452 void printPretty(raw_ostream &OS,
8453 const PrintingPolicy &Policy) const;
8454 const char *getSpelling() const;
8455
8456
8457 static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsTwice; }
8458};
8459
8460class SPtrAttr : public TypeAttr {
8461public:
8462 static SPtrAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8463 auto *A = new (Ctx) SPtrAttr(Loc, Ctx, 0);
8464 A->setImplicit(true);
8465 return A;
8466 }
8467
8468 SPtrAttr(SourceRange R, ASTContext &Ctx
8469 , unsigned SI
8470 )
8471 : TypeAttr(attr::SPtr, R, SI, false)
8472 {
8473 }
8474
8475 SPtrAttr *clone(ASTContext &C) const;
8476 void printPretty(raw_ostream &OS,
8477 const PrintingPolicy &Policy) const;
8478 const char *getSpelling() const;
8479
8480
8481 static bool classof(const Attr *A) { return A->getKind() == attr::SPtr; }
8482};
8483
8484class ScopedLockableAttr : public InheritableAttr {
8485public:
8486 static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8487 auto *A = new (Ctx) ScopedLockableAttr(Loc, Ctx, 0);
8488 A->setImplicit(true);
8489 return A;
8490 }
8491
8492 ScopedLockableAttr(SourceRange R, ASTContext &Ctx
8493 , unsigned SI
8494 )
8495 : InheritableAttr(attr::ScopedLockable, R, SI, false, false)
8496 {
8497 }
8498
8499 ScopedLockableAttr *clone(ASTContext &C) const;
8500 void printPretty(raw_ostream &OS,
8501 const PrintingPolicy &Policy) const;
8502 const char *getSpelling() const;
8503
8504
8505 static bool classof(const Attr *A) { return A->getKind() == attr::ScopedLockable; }
8506};
8507
8508class SectionAttr : public InheritableAttr {
8509unsigned nameLength;
8510char *name;
8511
8512public:
8513 enum Spelling {
8514 GNU_section = 0,
8515 CXX11_gnu_section = 1,
8516 Declspec_allocate = 2
8517 };
8518
8519 static SectionAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
8520 auto *A = new (Ctx) SectionAttr(Loc, Ctx, Name, S);
8521 A->setImplicit(true);
8522 return A;
8523 }
8524
8525 SectionAttr(SourceRange R, ASTContext &Ctx
8526 , llvm::StringRef Name
8527 , unsigned SI
8528 )
8529 : InheritableAttr(attr::Section, R, SI, false, false)
8530 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
8531 {
8532 if (!Name.empty())
8533 std::memcpy(name, Name.data(), nameLength);
8534 }
8535
8536 SectionAttr *clone(ASTContext &C) const;
8537 void printPretty(raw_ostream &OS,
8538 const PrintingPolicy &Policy) const;
8539 const char *getSpelling() const;
8540 Spelling getSemanticSpelling() const {
8541 switch (SpellingListIndex) {
8542 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8542)
;
8543 case 0: return GNU_section;
8544 case 1: return CXX11_gnu_section;
8545 case 2: return Declspec_allocate;
8546 }
8547 }
8548 llvm::StringRef getName() const {
8549 return llvm::StringRef(name, nameLength);
8550 }
8551 unsigned getNameLength() const {
8552 return nameLength;
8553 }
8554 void setName(ASTContext &C, llvm::StringRef S) {
8555 nameLength = S.size();
8556 this->name = new (C, 1) char [nameLength];
8557 if (!S.empty())
8558 std::memcpy(this->name, S.data(), nameLength);
8559 }
8560
8561
8562
8563 static bool classof(const Attr *A) { return A->getKind() == attr::Section; }
8564};
8565
8566class SelectAnyAttr : public InheritableAttr {
8567public:
8568 static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8569 auto *A = new (Ctx) SelectAnyAttr(Loc, Ctx, 0);
8570 A->setImplicit(true);
8571 return A;
8572 }
8573
8574 SelectAnyAttr(SourceRange R, ASTContext &Ctx
8575 , unsigned SI
8576 )
8577 : InheritableAttr(attr::SelectAny, R, SI, false, false)
8578 {
8579 }
8580
8581 SelectAnyAttr *clone(ASTContext &C) const;
8582 void printPretty(raw_ostream &OS,
8583 const PrintingPolicy &Policy) const;
8584 const char *getSpelling() const;
8585
8586
8587 static bool classof(const Attr *A) { return A->getKind() == attr::SelectAny; }
8588};
8589
8590class SentinelAttr : public InheritableAttr {
8591int sentinel;
8592
8593int nullPos;
8594
8595public:
8596 static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Loc = SourceRange()) {
8597 auto *A = new (Ctx) SentinelAttr(Loc, Ctx, Sentinel, NullPos, 0);
8598 A->setImplicit(true);
8599 return A;
8600 }
8601
8602 SentinelAttr(SourceRange R, ASTContext &Ctx
8603 , int Sentinel
8604 , int NullPos
8605 , unsigned SI
8606 )
8607 : InheritableAttr(attr::Sentinel, R, SI, false, false)
8608 , sentinel(Sentinel)
8609 , nullPos(NullPos)
8610 {
8611 }
8612
8613 SentinelAttr(SourceRange R, ASTContext &Ctx
8614 , unsigned SI
8615 )
8616 : InheritableAttr(attr::Sentinel, R, SI, false, false)
8617 , sentinel()
8618 , nullPos()
8619 {
8620 }
8621
8622 SentinelAttr *clone(ASTContext &C) const;
8623 void printPretty(raw_ostream &OS,
8624 const PrintingPolicy &Policy) const;
8625 const char *getSpelling() const;
8626 int getSentinel() const {
8627 return sentinel;
8628 }
8629
8630 static const int DefaultSentinel = 0;
8631
8632 int getNullPos() const {
8633 return nullPos;
8634 }
8635
8636 static const int DefaultNullPos = 0;
8637
8638
8639
8640 static bool classof(const Attr *A) { return A->getKind() == attr::Sentinel; }
8641};
8642
8643class SetTypestateAttr : public InheritableAttr {
8644public:
8645 enum ConsumedState {
8646 Unknown,
8647 Consumed,
8648 Unconsumed
8649 };
8650private:
8651 ConsumedState newState;
8652
8653public:
8654 static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState NewState, SourceRange Loc = SourceRange()) {
8655 auto *A = new (Ctx) SetTypestateAttr(Loc, Ctx, NewState, 0);
8656 A->setImplicit(true);
8657 return A;
8658 }
8659
8660 SetTypestateAttr(SourceRange R, ASTContext &Ctx
8661 , ConsumedState NewState
8662 , unsigned SI
8663 )
8664 : InheritableAttr(attr::SetTypestate, R, SI, false, false)
8665 , newState(NewState)
8666 {
8667 }
8668
8669 SetTypestateAttr *clone(ASTContext &C) const;
8670 void printPretty(raw_ostream &OS,
8671 const PrintingPolicy &Policy) const;
8672 const char *getSpelling() const;
8673 ConsumedState getNewState() const {
8674 return newState;
8675 }
8676
8677 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
8678 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
8679 .Case("unknown", SetTypestateAttr::Unknown)
8680 .Case("consumed", SetTypestateAttr::Consumed)
8681 .Case("unconsumed", SetTypestateAttr::Unconsumed)
8682 .Default(Optional<ConsumedState>());
8683 if (R) {
8684 Out = *R;
8685 return true;
8686 }
8687 return false;
8688 }
8689
8690 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
8691 switch(Val) {
8692 case SetTypestateAttr::Unknown: return "unknown";
8693 case SetTypestateAttr::Consumed: return "consumed";
8694 case SetTypestateAttr::Unconsumed: return "unconsumed";
8695 }
8696 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8696)
;
8697 }
8698
8699
8700 static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; }
8701};
8702
8703class SharedTrylockFunctionAttr : public InheritableAttr {
8704Expr * successValue;
8705
8706 unsigned args_Size;
8707 Expr * *args_;
8708
8709public:
8710 static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
8711 auto *A = new (Ctx) SharedTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
8712 A->setImplicit(true);
8713 return A;
8714 }
8715
8716 SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
8717 , Expr * SuccessValue
8718 , Expr * *Args, unsigned ArgsSize
8719 , unsigned SI
8720 )
8721 : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true)
8722 , successValue(SuccessValue)
8723 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
8724 {
8725 std::copy(Args, Args + args_Size, args_);
8726 }
8727
8728 SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
8729 , Expr * SuccessValue
8730 , unsigned SI
8731 )
8732 : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true)
8733 , successValue(SuccessValue)
8734 , args_Size(0), args_(nullptr)
8735 {
8736 }
8737
8738 SharedTrylockFunctionAttr *clone(ASTContext &C) const;
8739 void printPretty(raw_ostream &OS,
8740 const PrintingPolicy &Policy) const;
8741 const char *getSpelling() const;
8742 Expr * getSuccessValue() const {
8743 return successValue;
8744 }
8745
8746 typedef Expr ** args_iterator;
8747 args_iterator args_begin() const { return args_; }
8748 args_iterator args_end() const { return args_ + args_Size; }
8749 unsigned args_size() const { return args_Size; }
8750 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
8751
8752
8753
8754
8755 static bool classof(const Attr *A) { return A->getKind() == attr::SharedTrylockFunction; }
8756};
8757
8758class SpeculativeLoadHardeningAttr : public InheritableAttr {
8759public:
8760 static SpeculativeLoadHardeningAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8761 auto *A = new (Ctx) SpeculativeLoadHardeningAttr(Loc, Ctx, 0);
8762 A->setImplicit(true);
8763 return A;
8764 }
8765
8766 SpeculativeLoadHardeningAttr(SourceRange R, ASTContext &Ctx
8767 , unsigned SI
8768 )
8769 : InheritableAttr(attr::SpeculativeLoadHardening, R, SI, false, false)
8770 {
8771 }
8772
8773 SpeculativeLoadHardeningAttr *clone(ASTContext &C) const;
8774 void printPretty(raw_ostream &OS,
8775 const PrintingPolicy &Policy) const;
8776 const char *getSpelling() const;
8777
8778
8779 static bool classof(const Attr *A) { return A->getKind() == attr::SpeculativeLoadHardening; }
8780};
8781
8782class StdCallAttr : public InheritableAttr {
8783public:
8784 static StdCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8785 auto *A = new (Ctx) StdCallAttr(Loc, Ctx, 0);
8786 A->setImplicit(true);
8787 return A;
8788 }
8789
8790 StdCallAttr(SourceRange R, ASTContext &Ctx
8791 , unsigned SI
8792 )
8793 : InheritableAttr(attr::StdCall, R, SI, false, false)
8794 {
8795 }
8796
8797 StdCallAttr *clone(ASTContext &C) const;
8798 void printPretty(raw_ostream &OS,
8799 const PrintingPolicy &Policy) const;
8800 const char *getSpelling() const;
8801
8802
8803 static bool classof(const Attr *A) { return A->getKind() == attr::StdCall; }
8804};
8805
8806class SuppressAttr : public StmtAttr {
8807 unsigned diagnosticIdentifiers_Size;
8808 StringRef *diagnosticIdentifiers_;
8809
8810public:
8811 static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Loc = SourceRange()) {
8812 auto *A = new (Ctx) SuppressAttr(Loc, Ctx, DiagnosticIdentifiers, DiagnosticIdentifiersSize, 0);
8813 A->setImplicit(true);
8814 return A;
8815 }
8816
8817 SuppressAttr(SourceRange R, ASTContext &Ctx
8818 , StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize
8819 , unsigned SI
8820 )
8821 : StmtAttr(attr::Suppress, R, SI, false)
8822 , diagnosticIdentifiers_Size(DiagnosticIdentifiersSize), diagnosticIdentifiers_(new (Ctx, 16) StringRef[diagnosticIdentifiers_Size])
8823 {
8824 for (size_t I = 0, E = diagnosticIdentifiers_Size; I != E;
8825 ++I) {
8826 StringRef Ref = DiagnosticIdentifiers[I];
8827 if (!Ref.empty()) {
8828 char *Mem = new (Ctx, 1) char[Ref.size()];
8829 std::memcpy(Mem, Ref.data(), Ref.size());
8830 diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size());
8831 }
8832 }
8833 }
8834
8835 SuppressAttr(SourceRange R, ASTContext &Ctx
8836 , unsigned SI
8837 )
8838 : StmtAttr(attr::Suppress, R, SI, false)
8839 , diagnosticIdentifiers_Size(0), diagnosticIdentifiers_(nullptr)
8840 {
8841 }
8842
8843 SuppressAttr *clone(ASTContext &C) const;
8844 void printPretty(raw_ostream &OS,
8845 const PrintingPolicy &Policy) const;
8846 const char *getSpelling() const;
8847 typedef StringRef* diagnosticIdentifiers_iterator;
8848 diagnosticIdentifiers_iterator diagnosticIdentifiers_begin() const { return diagnosticIdentifiers_; }
8849 diagnosticIdentifiers_iterator diagnosticIdentifiers_end() const { return diagnosticIdentifiers_ + diagnosticIdentifiers_Size; }
8850 unsigned diagnosticIdentifiers_size() const { return diagnosticIdentifiers_Size; }
8851 llvm::iterator_range<diagnosticIdentifiers_iterator> diagnosticIdentifiers() const { return llvm::make_range(diagnosticIdentifiers_begin(), diagnosticIdentifiers_end()); }
8852
8853
8854
8855
8856 static bool classof(const Attr *A) { return A->getKind() == attr::Suppress; }
8857};
8858
8859class SwiftCallAttr : public InheritableAttr {
8860public:
8861 static SwiftCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8862 auto *A = new (Ctx) SwiftCallAttr(Loc, Ctx, 0);
8863 A->setImplicit(true);
8864 return A;
8865 }
8866
8867 SwiftCallAttr(SourceRange R, ASTContext &Ctx
8868 , unsigned SI
8869 )
8870 : InheritableAttr(attr::SwiftCall, R, SI, false, false)
8871 {
8872 }
8873
8874 SwiftCallAttr *clone(ASTContext &C) const;
8875 void printPretty(raw_ostream &OS,
8876 const PrintingPolicy &Policy) const;
8877 const char *getSpelling() const;
8878
8879
8880 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftCall; }
8881};
8882
8883class SwiftContextAttr : public ParameterABIAttr {
8884public:
8885 static SwiftContextAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8886 auto *A = new (Ctx) SwiftContextAttr(Loc, Ctx, 0);
8887 A->setImplicit(true);
8888 return A;
8889 }
8890
8891 SwiftContextAttr(SourceRange R, ASTContext &Ctx
8892 , unsigned SI
8893 )
8894 : ParameterABIAttr(attr::SwiftContext, R, SI, false, false)
8895 {
8896 }
8897
8898 SwiftContextAttr *clone(ASTContext &C) const;
8899 void printPretty(raw_ostream &OS,
8900 const PrintingPolicy &Policy) const;
8901 const char *getSpelling() const;
8902
8903
8904 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftContext; }
8905};
8906
8907class SwiftErrorResultAttr : public ParameterABIAttr {
8908public:
8909 static SwiftErrorResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8910 auto *A = new (Ctx) SwiftErrorResultAttr(Loc, Ctx, 0);
8911 A->setImplicit(true);
8912 return A;
8913 }
8914
8915 SwiftErrorResultAttr(SourceRange R, ASTContext &Ctx
8916 , unsigned SI
8917 )
8918 : ParameterABIAttr(attr::SwiftErrorResult, R, SI, false, false)
8919 {
8920 }
8921
8922 SwiftErrorResultAttr *clone(ASTContext &C) const;
8923 void printPretty(raw_ostream &OS,
8924 const PrintingPolicy &Policy) const;
8925 const char *getSpelling() const;
8926
8927
8928 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftErrorResult; }
8929};
8930
8931class SwiftIndirectResultAttr : public ParameterABIAttr {
8932public:
8933 static SwiftIndirectResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8934 auto *A = new (Ctx) SwiftIndirectResultAttr(Loc, Ctx, 0);
8935 A->setImplicit(true);
8936 return A;
8937 }
8938
8939 SwiftIndirectResultAttr(SourceRange R, ASTContext &Ctx
8940 , unsigned SI
8941 )
8942 : ParameterABIAttr(attr::SwiftIndirectResult, R, SI, false, false)
8943 {
8944 }
8945
8946 SwiftIndirectResultAttr *clone(ASTContext &C) const;
8947 void printPretty(raw_ostream &OS,
8948 const PrintingPolicy &Policy) const;
8949 const char *getSpelling() const;
8950
8951
8952 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftIndirectResult; }
8953};
8954
8955class SysVABIAttr : public InheritableAttr {
8956public:
8957 static SysVABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
8958 auto *A = new (Ctx) SysVABIAttr(Loc, Ctx, 0);
8959 A->setImplicit(true);
8960 return A;
8961 }
8962
8963 SysVABIAttr(SourceRange R, ASTContext &Ctx
8964 , unsigned SI
8965 )
8966 : InheritableAttr(attr::SysVABI, R, SI, false, false)
8967 {
8968 }
8969
8970 SysVABIAttr *clone(ASTContext &C) const;
8971 void printPretty(raw_ostream &OS,
8972 const PrintingPolicy &Policy) const;
8973 const char *getSpelling() const;
8974
8975
8976 static bool classof(const Attr *A) { return A->getKind() == attr::SysVABI; }
8977};
8978
8979class TLSModelAttr : public InheritableAttr {
8980unsigned modelLength;
8981char *model;
8982
8983public:
8984 static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, SourceRange Loc = SourceRange()) {
8985 auto *A = new (Ctx) TLSModelAttr(Loc, Ctx, Model, 0);
8986 A->setImplicit(true);
8987 return A;
8988 }
8989
8990 TLSModelAttr(SourceRange R, ASTContext &Ctx
8991 , llvm::StringRef Model
8992 , unsigned SI
8993 )
8994 : InheritableAttr(attr::TLSModel, R, SI, false, false)
8995 , modelLength(Model.size()),model(new (Ctx, 1) char[modelLength])
8996 {
8997 if (!Model.empty())
8998 std::memcpy(model, Model.data(), modelLength);
8999 }
9000
9001 TLSModelAttr *clone(ASTContext &C) const;
9002 void printPretty(raw_ostream &OS,
9003 const PrintingPolicy &Policy) const;
9004 const char *getSpelling() const;
9005 llvm::StringRef getModel() const {
9006 return llvm::StringRef(model, modelLength);
9007 }
9008 unsigned getModelLength() const {
9009 return modelLength;
9010 }
9011 void setModel(ASTContext &C, llvm::StringRef S) {
9012 modelLength = S.size();
9013 this->model = new (C, 1) char [modelLength];
9014 if (!S.empty())
9015 std::memcpy(this->model, S.data(), modelLength);
9016 }
9017
9018
9019
9020 static bool classof(const Attr *A) { return A->getKind() == attr::TLSModel; }
9021};
9022
9023class TargetAttr : public InheritableAttr {
9024unsigned featuresStrLength;
9025char *featuresStr;
9026
9027public:
9028 static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef FeaturesStr, SourceRange Loc = SourceRange()) {
9029 auto *A = new (Ctx) TargetAttr(Loc, Ctx, FeaturesStr, 0);
9030 A->setImplicit(true);
9031 return A;
9032 }
9033
9034 TargetAttr(SourceRange R, ASTContext &Ctx
9035 , llvm::StringRef FeaturesStr
9036 , unsigned SI
9037 )
9038 : InheritableAttr(attr::Target, R, SI, false, false)
9039 , featuresStrLength(FeaturesStr.size()),featuresStr(new (Ctx, 1) char[featuresStrLength])
9040 {
9041 if (!FeaturesStr.empty())
9042 std::memcpy(featuresStr, FeaturesStr.data(), featuresStrLength);
9043 }
9044
9045 TargetAttr *clone(ASTContext &C) const;
9046 void printPretty(raw_ostream &OS,
9047 const PrintingPolicy &Policy) const;
9048 const char *getSpelling() const;
9049 llvm::StringRef getFeaturesStr() const {
9050 return llvm::StringRef(featuresStr, featuresStrLength);
9051 }
9052 unsigned getFeaturesStrLength() const {
9053 return featuresStrLength;
9054 }
9055 void setFeaturesStr(ASTContext &C, llvm::StringRef S) {
9056 featuresStrLength = S.size();
9057 this->featuresStr = new (C, 1) char [featuresStrLength];
9058 if (!S.empty())
9059 std::memcpy(this->featuresStr, S.data(), featuresStrLength);
9060 }
9061
9062
9063 struct ParsedTargetAttr {
9064 std::vector<std::string> Features;
9065 StringRef Architecture;
9066 bool DuplicateArchitecture = false;
9067 bool operator ==(const ParsedTargetAttr &Other) const {
9068 return DuplicateArchitecture == Other.DuplicateArchitecture &&
9069 Architecture == Other.Architecture && Features == Other.Features;
9070 }
9071 };
9072 ParsedTargetAttr parse() const {
9073 return parse(getFeaturesStr());
9074 }
9075
9076 StringRef getArchitecture() const {
9077 StringRef Features = getFeaturesStr();
9078 if (Features == "default") return {};
9079
9080 SmallVector<StringRef, 1> AttrFeatures;
9081 Features.split(AttrFeatures, ",");
9082
9083 for (auto &Feature : AttrFeatures) {
9084 Feature = Feature.trim();
9085 if (Feature.startswith("arch="))
9086 return Feature.drop_front(sizeof("arch=") - 1);
9087 }
9088 return "";
9089 }
9090
9091 // Gets the list of features as simple string-refs with no +/- or 'no-'.
9092 // Only adds the items to 'Out' that are additions.
9093 void getAddedFeatures(llvm::SmallVectorImpl<StringRef> &Out) const {
9094 StringRef Features = getFeaturesStr();
9095 if (Features == "default") return;
9096
9097 SmallVector<StringRef, 1> AttrFeatures;
9098 Features.split(AttrFeatures, ",");
9099
9100 for (auto &Feature : AttrFeatures) {
9101 Feature = Feature.trim();
9102
9103 if (!Feature.startswith("no-") && !Feature.startswith("arch=") &&
9104 !Feature.startswith("fpmath=") && !Feature.startswith("tune="))
9105 Out.push_back(Feature);
9106 }
9107 }
9108
9109 template<class Compare>
9110 ParsedTargetAttr parse(Compare cmp) const {
9111 ParsedTargetAttr Attrs = parse();
9112 llvm::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp);
9113 return Attrs;
9114 }
9115
9116 bool isDefaultVersion() const { return getFeaturesStr() == "default"; }
9117
9118 static ParsedTargetAttr parse(StringRef Features) {
9119 ParsedTargetAttr Ret;
9120 if (Features == "default") return Ret;
9121 SmallVector<StringRef, 1> AttrFeatures;
9122 Features.split(AttrFeatures, ",");
9123
9124 // Grab the various features and prepend a "+" to turn on the feature to
9125 // the backend and add them to our existing set of features.
9126 for (auto &Feature : AttrFeatures) {
9127 // Go ahead and trim whitespace rather than either erroring or
9128 // accepting it weirdly.
9129 Feature = Feature.trim();
9130
9131 // We don't support cpu tuning this way currently.
9132 // TODO: Support the fpmath option. It will require checking
9133 // overall feature validity for the function with the rest of the
9134 // attributes on the function.
9135 if (Feature.startswith("fpmath=") || Feature.startswith("tune="))
9136 continue;
9137
9138 // While we're here iterating check for a different target cpu.
9139 if (Feature.startswith("arch=")) {
9140 if (!Ret.Architecture.empty())
9141 Ret.DuplicateArchitecture = true;
9142 else
9143 Ret.Architecture = Feature.split("=").second.trim();
9144 } else if (Feature.startswith("no-"))
9145 Ret.Features.push_back("-" + Feature.split("-").second.str());
9146 else
9147 Ret.Features.push_back("+" + Feature.str());
9148 }
9149 return Ret;
9150 }
9151
9152
9153 static bool classof(const Attr *A) { return A->getKind() == attr::Target; }
9154};
9155
9156class TestTypestateAttr : public InheritableAttr {
9157public:
9158 enum ConsumedState {
9159 Consumed,
9160 Unconsumed
9161 };
9162private:
9163 ConsumedState testState;
9164
9165public:
9166 static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState TestState, SourceRange Loc = SourceRange()) {
9167 auto *A = new (Ctx) TestTypestateAttr(Loc, Ctx, TestState, 0);
9168 A->setImplicit(true);
9169 return A;
9170 }
9171
9172 TestTypestateAttr(SourceRange R, ASTContext &Ctx
9173 , ConsumedState TestState
9174 , unsigned SI
9175 )
9176 : InheritableAttr(attr::TestTypestate, R, SI, false, false)
9177 , testState(TestState)
9178 {
9179 }
9180
9181 TestTypestateAttr *clone(ASTContext &C) const;
9182 void printPretty(raw_ostream &OS,
9183 const PrintingPolicy &Policy) const;
9184 const char *getSpelling() const;
9185 ConsumedState getTestState() const {
9186 return testState;
9187 }
9188
9189 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
9190 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
9191 .Case("consumed", TestTypestateAttr::Consumed)
9192 .Case("unconsumed", TestTypestateAttr::Unconsumed)
9193 .Default(Optional<ConsumedState>());
9194 if (R) {
9195 Out = *R;
9196 return true;
9197 }
9198 return false;
9199 }
9200
9201 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
9202 switch(Val) {
9203 case TestTypestateAttr::Consumed: return "consumed";
9204 case TestTypestateAttr::Unconsumed: return "unconsumed";
9205 }
9206 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9206)
;
9207 }
9208
9209
9210 static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; }
9211};
9212
9213class ThisCallAttr : public InheritableAttr {
9214public:
9215 static ThisCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9216 auto *A = new (Ctx) ThisCallAttr(Loc, Ctx, 0);
9217 A->setImplicit(true);
9218 return A;
9219 }
9220
9221 ThisCallAttr(SourceRange R, ASTContext &Ctx
9222 , unsigned SI
9223 )
9224 : InheritableAttr(attr::ThisCall, R, SI, false, false)
9225 {
9226 }
9227
9228 ThisCallAttr *clone(ASTContext &C) const;
9229 void printPretty(raw_ostream &OS,
9230 const PrintingPolicy &Policy) const;
9231 const char *getSpelling() const;
9232
9233
9234 static bool classof(const Attr *A) { return A->getKind() == attr::ThisCall; }
9235};
9236
9237class ThreadAttr : public Attr {
9238public:
9239 static ThreadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9240 auto *A = new (Ctx) ThreadAttr(Loc, Ctx, 0);
9241 A->setImplicit(true);
9242 return A;
9243 }
9244
9245 ThreadAttr(SourceRange R, ASTContext &Ctx
9246 , unsigned SI
9247 )
9248 : Attr(attr::Thread, R, SI, false)
9249 {
9250 }
9251
9252 ThreadAttr *clone(ASTContext &C) const;
9253 void printPretty(raw_ostream &OS,
9254 const PrintingPolicy &Policy) const;
9255 const char *getSpelling() const;
9256
9257
9258 static bool classof(const Attr *A) { return A->getKind() == attr::Thread; }
9259};
9260
9261class TransparentUnionAttr : public InheritableAttr {
9262public:
9263 static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9264 auto *A = new (Ctx) TransparentUnionAttr(Loc, Ctx, 0);
9265 A->setImplicit(true);
9266 return A;
9267 }
9268
9269 TransparentUnionAttr(SourceRange R, ASTContext &Ctx
9270 , unsigned SI
9271 )
9272 : InheritableAttr(attr::TransparentUnion, R, SI, false, false)
9273 {
9274 }
9275
9276 TransparentUnionAttr *clone(ASTContext &C) const;
9277 void printPretty(raw_ostream &OS,
9278 const PrintingPolicy &Policy) const;
9279 const char *getSpelling() const;
9280
9281
9282 static bool classof(const Attr *A) { return A->getKind() == attr::TransparentUnion; }
9283};
9284
9285class TrivialABIAttr : public InheritableAttr {
9286public:
9287 static TrivialABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9288 auto *A = new (Ctx) TrivialABIAttr(Loc, Ctx, 0);
9289 A->setImplicit(true);
9290 return A;
9291 }
9292
9293 TrivialABIAttr(SourceRange R, ASTContext &Ctx
9294 , unsigned SI
9295 )
9296 : InheritableAttr(attr::TrivialABI, R, SI, false, false)
9297 {
9298 }
9299
9300 TrivialABIAttr *clone(ASTContext &C) const;
9301 void printPretty(raw_ostream &OS,
9302 const PrintingPolicy &Policy) const;
9303 const char *getSpelling() const;
9304
9305
9306 static bool classof(const Attr *A) { return A->getKind() == attr::TrivialABI; }
9307};
9308
9309class TryAcquireCapabilityAttr : public InheritableAttr {
9310Expr * successValue;
9311
9312 unsigned args_Size;
9313 Expr * *args_;
9314
9315public:
9316 enum Spelling {
9317 GNU_try_acquire_capability = 0,
9318 CXX11_clang_try_acquire_capability = 1,
9319 GNU_try_acquire_shared_capability = 2,
9320 CXX11_clang_try_acquire_shared_capability = 3
9321 };
9322
9323 static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
9324 auto *A = new (Ctx) TryAcquireCapabilityAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, S);
9325 A->setImplicit(true);
9326 return A;
9327 }
9328
9329 TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
9330 , Expr * SuccessValue
9331 , Expr * *Args, unsigned ArgsSize
9332 , unsigned SI
9333 )
9334 : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true)
9335 , successValue(SuccessValue)
9336 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
9337 {
9338 std::copy(Args, Args + args_Size, args_);
9339 }
9340
9341 TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
9342 , Expr * SuccessValue
9343 , unsigned SI
9344 )
9345 : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true)
9346 , successValue(SuccessValue)
9347 , args_Size(0), args_(nullptr)
9348 {
9349 }
9350
9351 TryAcquireCapabilityAttr *clone(ASTContext &C) const;
9352 void printPretty(raw_ostream &OS,
9353 const PrintingPolicy &Policy) const;
9354 const char *getSpelling() const;
9355 Spelling getSemanticSpelling() const {
9356 switch (SpellingListIndex) {
9357 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9357)
;
9358 case 0: return GNU_try_acquire_capability;
9359 case 1: return CXX11_clang_try_acquire_capability;
9360 case 2: return GNU_try_acquire_shared_capability;
9361 case 3: return CXX11_clang_try_acquire_shared_capability;
9362 }
9363 }
9364 bool isShared() const { return SpellingListIndex == 2 ||
9365 SpellingListIndex == 3; }
9366 Expr * getSuccessValue() const {
9367 return successValue;
9368 }
9369
9370 typedef Expr ** args_iterator;
9371 args_iterator args_begin() const { return args_; }
9372 args_iterator args_end() const { return args_ + args_Size; }
9373 unsigned args_size() const { return args_Size; }
9374 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
9375
9376
9377
9378
9379 static bool classof(const Attr *A) { return A->getKind() == attr::TryAcquireCapability; }
9380};
9381
9382class TypeNonNullAttr : public TypeAttr {
9383public:
9384 static TypeNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9385 auto *A = new (Ctx) TypeNonNullAttr(Loc, Ctx, 0);
9386 A->setImplicit(true);
9387 return A;
9388 }
9389
9390 TypeNonNullAttr(SourceRange R, ASTContext &Ctx
9391 , unsigned SI
9392 )
9393 : TypeAttr(attr::TypeNonNull, R, SI, false)
9394 {
9395 }
9396
9397 TypeNonNullAttr *clone(ASTContext &C) const;
9398 void printPretty(raw_ostream &OS,
9399 const PrintingPolicy &Policy) const;
9400 const char *getSpelling() const;
9401
9402
9403 static bool classof(const Attr *A) { return A->getKind() == attr::TypeNonNull; }
9404};
9405
9406class TypeNullUnspecifiedAttr : public TypeAttr {
9407public:
9408 static TypeNullUnspecifiedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9409 auto *A = new (Ctx) TypeNullUnspecifiedAttr(Loc, Ctx, 0);
9410 A->setImplicit(true);
9411 return A;
9412 }
9413
9414 TypeNullUnspecifiedAttr(SourceRange R, ASTContext &Ctx
9415 , unsigned SI
9416 )
9417 : TypeAttr(attr::TypeNullUnspecified, R, SI, false)
9418 {
9419 }
9420
9421 TypeNullUnspecifiedAttr *clone(ASTContext &C) const;
9422 void printPretty(raw_ostream &OS,
9423 const PrintingPolicy &Policy) const;
9424 const char *getSpelling() const;
9425
9426
9427 static bool classof(const Attr *A) { return A->getKind() == attr::TypeNullUnspecified; }
9428};
9429
9430class TypeNullableAttr : public TypeAttr {
9431public:
9432 static TypeNullableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9433 auto *A = new (Ctx) TypeNullableAttr(Loc, Ctx, 0);
9434 A->setImplicit(true);
9435 return A;
9436 }
9437
9438 TypeNullableAttr(SourceRange R, ASTContext &Ctx
9439 , unsigned SI
9440 )
9441 : TypeAttr(attr::TypeNullable, R, SI, false)
9442 {
9443 }
9444
9445 TypeNullableAttr *clone(ASTContext &C) const;
9446 void printPretty(raw_ostream &OS,
9447 const PrintingPolicy &Policy) const;
9448 const char *getSpelling() const;
9449
9450
9451 static bool classof(const Attr *A) { return A->getKind() == attr::TypeNullable; }
9452};
9453
9454class TypeTagForDatatypeAttr : public InheritableAttr {
9455IdentifierInfo * argumentKind;
9456
9457TypeSourceInfo * matchingCType;
9458
9459bool layoutCompatible;
9460
9461bool mustBeNull;
9462
9463public:
9464 static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Loc = SourceRange()) {
9465 auto *A = new (Ctx) TypeTagForDatatypeAttr(Loc, Ctx, ArgumentKind, MatchingCType, LayoutCompatible, MustBeNull, 0);
9466 A->setImplicit(true);
9467 return A;
9468 }
9469
9470 TypeTagForDatatypeAttr(SourceRange R, ASTContext &Ctx
9471 , IdentifierInfo * ArgumentKind
9472 , TypeSourceInfo * MatchingCType
9473 , bool LayoutCompatible
9474 , bool MustBeNull
9475 , unsigned SI
9476 )
9477 : InheritableAttr(attr::TypeTagForDatatype, R, SI, false, false)
9478 , argumentKind(ArgumentKind)
9479 , matchingCType(MatchingCType)
9480 , layoutCompatible(LayoutCompatible)
9481 , mustBeNull(MustBeNull)
9482 {
9483 }
9484
9485 TypeTagForDatatypeAttr *clone(ASTContext &C) const;
9486 void printPretty(raw_ostream &OS,
9487 const PrintingPolicy &Policy) const;
9488 const char *getSpelling() const;
9489 IdentifierInfo * getArgumentKind() const {
9490 return argumentKind;
9491 }
9492
9493 QualType getMatchingCType() const {
9494 return matchingCType->getType();
9495 } TypeSourceInfo * getMatchingCTypeLoc() const {
9496 return matchingCType;
9497 }
9498
9499 bool getLayoutCompatible() const {
9500 return layoutCompatible;
9501 }
9502
9503 bool getMustBeNull() const {
9504 return mustBeNull;
9505 }
9506
9507
9508
9509 static bool classof(const Attr *A) { return A->getKind() == attr::TypeTagForDatatype; }
9510};
9511
9512class TypeVisibilityAttr : public InheritableAttr {
9513public:
9514 enum VisibilityType {
9515 Default,
9516 Hidden,
9517 Protected
9518 };
9519private:
9520 VisibilityType visibility;
9521
9522public:
9523 static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
9524 auto *A = new (Ctx) TypeVisibilityAttr(Loc, Ctx, Visibility, 0);
9525 A->setImplicit(true);
9526 return A;
9527 }
9528
9529 TypeVisibilityAttr(SourceRange R, ASTContext &Ctx
9530 , VisibilityType Visibility
9531 , unsigned SI
9532 )
9533 : InheritableAttr(attr::TypeVisibility, R, SI, false, false)
9534 , visibility(Visibility)
9535 {
9536 }
9537
9538 TypeVisibilityAttr *clone(ASTContext &C) const;
9539 void printPretty(raw_ostream &OS,
9540 const PrintingPolicy &Policy) const;
9541 const char *getSpelling() const;
9542 VisibilityType getVisibility() const {
9543 return visibility;
9544 }
9545
9546 static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
9547 Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
9548 .Case("default", TypeVisibilityAttr::Default)
9549 .Case("hidden", TypeVisibilityAttr::Hidden)
9550 .Case("internal", TypeVisibilityAttr::Hidden)
9551 .Case("protected", TypeVisibilityAttr::Protected)
9552 .Default(Optional<VisibilityType>());
9553 if (R) {
9554 Out = *R;
9555 return true;
9556 }
9557 return false;
9558 }
9559
9560 static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
9561 switch(Val) {
9562 case TypeVisibilityAttr::Default: return "default";
9563 case TypeVisibilityAttr::Hidden: return "hidden";
9564 case TypeVisibilityAttr::Protected: return "protected";
9565 }
9566 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9566)
;
9567 }
9568
9569
9570 static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; }
9571};
9572
9573class UPtrAttr : public TypeAttr {
9574public:
9575 static UPtrAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9576 auto *A = new (Ctx) UPtrAttr(Loc, Ctx, 0);
9577 A->setImplicit(true);
9578 return A;
9579 }
9580
9581 UPtrAttr(SourceRange R, ASTContext &Ctx
9582 , unsigned SI
9583 )
9584 : TypeAttr(attr::UPtr, R, SI, false)
9585 {
9586 }
9587
9588 UPtrAttr *clone(ASTContext &C) const;
9589 void printPretty(raw_ostream &OS,
9590 const PrintingPolicy &Policy) const;
9591 const char *getSpelling() const;
9592
9593
9594 static bool classof(const Attr *A) { return A->getKind() == attr::UPtr; }
9595};
9596
9597class UnavailableAttr : public InheritableAttr {
9598unsigned messageLength;
9599char *message;
9600
9601public:
9602 enum ImplicitReason {
9603 IR_None,
9604 IR_ARCForbiddenType,
9605 IR_ForbiddenWeak,
9606 IR_ARCForbiddenConversion,
9607 IR_ARCInitReturnsUnrelated,
9608 IR_ARCFieldWithOwnership
9609 };
9610private:
9611 ImplicitReason implicitReason;
9612
9613public:
9614 static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, ImplicitReason ImplicitReason, SourceRange Loc = SourceRange()) {
9615 auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, ImplicitReason, 0);
6
Calling constructor for 'UnavailableAttr'
9616 A->setImplicit(true);
9617 return A;
9618 }
9619
9620 static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
9621 auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, 0);
9622 A->setImplicit(true);
9623 return A;
9624 }
9625
9626 UnavailableAttr(SourceRange R, ASTContext &Ctx
9627 , llvm::StringRef Message
9628 , ImplicitReason ImplicitReason
9629 , unsigned SI
9630 )
9631 : InheritableAttr(attr::Unavailable, R, SI, false, false)
9632 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
7
Null pointer value stored to field 'message'
9633 , implicitReason(ImplicitReason)
9634 {
9635 if (!Message.empty())
8
Assuming the condition is true
9
Taking true branch
9636 std::memcpy(message, Message.data(), messageLength);
10
Null pointer passed as an argument to a 'nonnull' parameter
9637 }
9638
9639 UnavailableAttr(SourceRange R, ASTContext &Ctx
9640 , llvm::StringRef Message
9641 , unsigned SI
9642 )
9643 : InheritableAttr(attr::Unavailable, R, SI, false, false)
9644 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
9645 , implicitReason(ImplicitReason(0))
9646 {
9647 if (!Message.empty())
9648 std::memcpy(message, Message.data(), messageLength);
9649 }
9650
9651 UnavailableAttr(SourceRange R, ASTContext &Ctx
9652 , unsigned SI
9653 )
9654 : InheritableAttr(attr::Unavailable, R, SI, false, false)
9655 , messageLength(0),message(nullptr)
9656 , implicitReason(ImplicitReason(0))
9657 {
9658 }
9659
9660 UnavailableAttr *clone(ASTContext &C) const;
9661 void printPretty(raw_ostream &OS,
9662 const PrintingPolicy &Policy) const;
9663 const char *getSpelling() const;
9664 llvm::StringRef getMessage() const {
9665 return llvm::StringRef(message, messageLength);
9666 }
9667 unsigned getMessageLength() const {
9668 return messageLength;
9669 }
9670 void setMessage(ASTContext &C, llvm::StringRef S) {
9671 messageLength = S.size();
9672 this->message = new (C, 1) char [messageLength];
9673 if (!S.empty())
9674 std::memcpy(this->message, S.data(), messageLength);
9675 }
9676
9677 ImplicitReason getImplicitReason() const {
9678 return implicitReason;
9679 }
9680
9681
9682
9683 static bool classof(const Attr *A) { return A->getKind() == attr::Unavailable; }
9684};
9685
9686class UninitializedAttr : public InheritableAttr {
9687public:
9688 static UninitializedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9689 auto *A = new (Ctx) UninitializedAttr(Loc, Ctx, 0);
9690 A->setImplicit(true);
9691 return A;
9692 }
9693
9694 UninitializedAttr(SourceRange R, ASTContext &Ctx
9695 , unsigned SI
9696 )
9697 : InheritableAttr(attr::Uninitialized, R, SI, false, false)
9698 {
9699 }
9700
9701 UninitializedAttr *clone(ASTContext &C) const;
9702 void printPretty(raw_ostream &OS,
9703 const PrintingPolicy &Policy) const;
9704 const char *getSpelling() const;
9705
9706
9707 static bool classof(const Attr *A) { return A->getKind() == attr::Uninitialized; }
9708};
9709
9710class UnusedAttr : public InheritableAttr {
9711public:
9712 enum Spelling {
9713 CXX11_maybe_unused = 0,
9714 GNU_unused = 1,
9715 CXX11_gnu_unused = 2,
9716 C2x_maybe_unused = 3
9717 };
9718
9719 static UnusedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
9720 auto *A = new (Ctx) UnusedAttr(Loc, Ctx, S);
9721 A->setImplicit(true);
9722 return A;
9723 }
9724
9725 UnusedAttr(SourceRange R, ASTContext &Ctx
9726 , unsigned SI
9727 )
9728 : InheritableAttr(attr::Unused, R, SI, false, false)
9729 {
9730 }
9731
9732 UnusedAttr *clone(ASTContext &C) const;
9733 void printPretty(raw_ostream &OS,
9734 const PrintingPolicy &Policy) const;
9735 const char *getSpelling() const;
9736 Spelling getSemanticSpelling() const {
9737 switch (SpellingListIndex) {
9738 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9738)
;
9739 case 0: return CXX11_maybe_unused;
9740 case 1: return GNU_unused;
9741 case 2: return CXX11_gnu_unused;
9742 case 3: return C2x_maybe_unused;
9743 }
9744 }
9745
9746
9747 static bool classof(const Attr *A) { return A->getKind() == attr::Unused; }
9748};
9749
9750class UsedAttr : public InheritableAttr {
9751public:
9752 static UsedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9753 auto *A = new (Ctx) UsedAttr(Loc, Ctx, 0);
9754 A->setImplicit(true);
9755 return A;
9756 }
9757
9758 UsedAttr(SourceRange R, ASTContext &Ctx
9759 , unsigned SI
9760 )
9761 : InheritableAttr(attr::Used, R, SI, false, false)
9762 {
9763 }
9764
9765 UsedAttr *clone(ASTContext &C) const;
9766 void printPretty(raw_ostream &OS,
9767 const PrintingPolicy &Policy) const;
9768 const char *getSpelling() const;
9769
9770
9771 static bool classof(const Attr *A) { return A->getKind() == attr::Used; }
9772};
9773
9774class UuidAttr : public InheritableAttr {
9775unsigned guidLength;
9776char *guid;
9777
9778public:
9779 static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Loc = SourceRange()) {
9780 auto *A = new (Ctx) UuidAttr(Loc, Ctx, Guid, 0);
9781 A->setImplicit(true);
9782 return A;
9783 }
9784
9785 UuidAttr(SourceRange R, ASTContext &Ctx
9786 , llvm::StringRef Guid
9787 , unsigned SI
9788 )
9789 : InheritableAttr(attr::Uuid, R, SI, false, false)
9790 , guidLength(Guid.size()),guid(new (Ctx, 1) char[guidLength])
9791 {
9792 if (!Guid.empty())
9793 std::memcpy(guid, Guid.data(), guidLength);
9794 }
9795
9796 UuidAttr *clone(ASTContext &C) const;
9797 void printPretty(raw_ostream &OS,
9798 const PrintingPolicy &Policy) const;
9799 const char *getSpelling() const;
9800 llvm::StringRef getGuid() const {
9801 return llvm::StringRef(guid, guidLength);
9802 }
9803 unsigned getGuidLength() const {
9804 return guidLength;
9805 }
9806 void setGuid(ASTContext &C, llvm::StringRef S) {
9807 guidLength = S.size();
9808 this->guid = new (C, 1) char [guidLength];
9809 if (!S.empty())
9810 std::memcpy(this->guid, S.data(), guidLength);
9811 }
9812
9813
9814
9815 static bool classof(const Attr *A) { return A->getKind() == attr::Uuid; }
9816};
9817
9818class VecReturnAttr : public InheritableAttr {
9819public:
9820 static VecReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9821 auto *A = new (Ctx) VecReturnAttr(Loc, Ctx, 0);
9822 A->setImplicit(true);
9823 return A;
9824 }
9825
9826 VecReturnAttr(SourceRange R, ASTContext &Ctx
9827 , unsigned SI
9828 )
9829 : InheritableAttr(attr::VecReturn, R, SI, false, false)
9830 {
9831 }
9832
9833 VecReturnAttr *clone(ASTContext &C) const;
9834 void printPretty(raw_ostream &OS,
9835 const PrintingPolicy &Policy) const;
9836 const char *getSpelling() const;
9837
9838
9839 static bool classof(const Attr *A) { return A->getKind() == attr::VecReturn; }
9840};
9841
9842class VecTypeHintAttr : public InheritableAttr {
9843TypeSourceInfo * typeHint;
9844
9845public:
9846 static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Loc = SourceRange()) {
9847 auto *A = new (Ctx) VecTypeHintAttr(Loc, Ctx, TypeHint, 0);
9848 A->setImplicit(true);
9849 return A;
9850 }
9851
9852 VecTypeHintAttr(SourceRange R, ASTContext &Ctx
9853 , TypeSourceInfo * TypeHint
9854 , unsigned SI
9855 )
9856 : InheritableAttr(attr::VecTypeHint, R, SI, false, false)
9857 , typeHint(TypeHint)
9858 {
9859 }
9860
9861 VecTypeHintAttr *clone(ASTContext &C) const;
9862 void printPretty(raw_ostream &OS,
9863 const PrintingPolicy &Policy) const;
9864 const char *getSpelling() const;
9865 QualType getTypeHint() const {
9866 return typeHint->getType();
9867 } TypeSourceInfo * getTypeHintLoc() const {
9868 return typeHint;
9869 }
9870
9871
9872
9873 static bool classof(const Attr *A) { return A->getKind() == attr::VecTypeHint; }
9874};
9875
9876class VectorCallAttr : public InheritableAttr {
9877public:
9878 static VectorCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9879 auto *A = new (Ctx) VectorCallAttr(Loc, Ctx, 0);
9880 A->setImplicit(true);
9881 return A;
9882 }
9883
9884 VectorCallAttr(SourceRange R, ASTContext &Ctx
9885 , unsigned SI
9886 )
9887 : InheritableAttr(attr::VectorCall, R, SI, false, false)
9888 {
9889 }
9890
9891 VectorCallAttr *clone(ASTContext &C) const;
9892 void printPretty(raw_ostream &OS,
9893 const PrintingPolicy &Policy) const;
9894 const char *getSpelling() const;
9895
9896
9897 static bool classof(const Attr *A) { return A->getKind() == attr::VectorCall; }
9898};
9899
9900class VisibilityAttr : public InheritableAttr {
9901public:
9902 enum VisibilityType {
9903 Default,
9904 Hidden,
9905 Protected
9906 };
9907private:
9908 VisibilityType visibility;
9909
9910public:
9911 static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
9912 auto *A = new (Ctx) VisibilityAttr(Loc, Ctx, Visibility, 0);
9913 A->setImplicit(true);
9914 return A;
9915 }
9916
9917 VisibilityAttr(SourceRange R, ASTContext &Ctx
9918 , VisibilityType Visibility
9919 , unsigned SI
9920 )
9921 : InheritableAttr(attr::Visibility, R, SI, false, false)
9922 , visibility(Visibility)
9923 {
9924 }
9925
9926 VisibilityAttr *clone(ASTContext &C) const;
9927 void printPretty(raw_ostream &OS,
9928 const PrintingPolicy &Policy) const;
9929 const char *getSpelling() const;
9930 VisibilityType getVisibility() const {
9931 return visibility;
9932 }
9933
9934 static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
9935 Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
9936 .Case("default", VisibilityAttr::Default)
9937 .Case("hidden", VisibilityAttr::Hidden)
9938 .Case("internal", VisibilityAttr::Hidden)
9939 .Case("protected", VisibilityAttr::Protected)
9940 .Default(Optional<VisibilityType>());
9941 if (R) {
9942 Out = *R;
9943 return true;
9944 }
9945 return false;
9946 }
9947
9948 static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
9949 switch(Val) {
9950 case VisibilityAttr::Default: return "default";
9951 case VisibilityAttr::Hidden: return "hidden";
9952 case VisibilityAttr::Protected: return "protected";
9953 }
9954 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9954)
;
9955 }
9956
9957
9958 static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; }
9959};
9960
9961class WarnUnusedAttr : public InheritableAttr {
9962public:
9963 static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
9964 auto *A = new (Ctx) WarnUnusedAttr(Loc, Ctx, 0);
9965 A->setImplicit(true);
9966 return A;
9967 }
9968
9969 WarnUnusedAttr(SourceRange R, ASTContext &Ctx
9970 , unsigned SI
9971 )
9972 : InheritableAttr(attr::WarnUnused, R, SI, false, false)
9973 {
9974 }
9975
9976 WarnUnusedAttr *clone(ASTContext &C) const;
9977 void printPretty(raw_ostream &OS,
9978 const PrintingPolicy &Policy) const;
9979 const char *getSpelling() const;
9980
9981
9982 static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnused; }
9983};
9984
9985class WarnUnusedResultAttr : public InheritableAttr {
9986public:
9987 enum Spelling {
9988 CXX11_nodiscard = 0,
9989 C2x_nodiscard = 1,
9990 CXX11_clang_warn_unused_result = 2,
9991 GNU_warn_unused_result = 3,
9992 CXX11_gnu_warn_unused_result = 4
9993 };
9994
9995 static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
9996 auto *A = new (Ctx) WarnUnusedResultAttr(Loc, Ctx, S);
9997 A->setImplicit(true);
9998 return A;
9999 }
10000
10001 WarnUnusedResultAttr(SourceRange R, ASTContext &Ctx
10002 , unsigned SI
10003 )
10004 : InheritableAttr(attr::WarnUnusedResult, R, SI, false, false)
10005 {
10006 }
10007
10008 WarnUnusedResultAttr *clone(ASTContext &C) const;
10009 void printPretty(raw_ostream &OS,
10010 const PrintingPolicy &Policy) const;
10011 const char *getSpelling() const;
10012 Spelling getSemanticSpelling() const {
10013 switch (SpellingListIndex) {
10014 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 10014)
;
10015 case 0: return CXX11_nodiscard;
10016 case 1: return C2x_nodiscard;
10017 case 2: return CXX11_clang_warn_unused_result;
10018 case 3: return GNU_warn_unused_result;
10019 case 4: return CXX11_gnu_warn_unused_result;
10020 }
10021 }
10022
10023
10024 static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnusedResult; }
10025};
10026
10027class WeakAttr : public InheritableAttr {
10028public:
10029 static WeakAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
10030 auto *A = new (Ctx) WeakAttr(Loc, Ctx, 0);
10031 A->setImplicit(true);
10032 return A;
10033 }
10034
10035 WeakAttr(SourceRange R, ASTContext &Ctx
10036 , unsigned SI
10037 )
10038 : InheritableAttr(attr::Weak, R, SI, false, false)
10039 {
10040 }
10041
10042 WeakAttr *clone(ASTContext &C) const;
10043 void printPretty(raw_ostream &OS,
10044 const PrintingPolicy &Policy) const;
10045 const char *getSpelling() const;
10046
10047
10048 static bool classof(const Attr *A) { return A->getKind() == attr::Weak; }
10049};
10050
10051class WeakImportAttr : public InheritableAttr {
10052public:
10053 static WeakImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
10054 auto *A = new (Ctx) WeakImportAttr(Loc, Ctx, 0);
10055 A->setImplicit(true);
10056 return A;
10057 }
10058
10059 WeakImportAttr(SourceRange R, ASTContext &Ctx
10060 , unsigned SI
10061 )
10062 : InheritableAttr(attr::WeakImport, R, SI, false, false)
10063 {
10064 }
10065
10066 WeakImportAttr *clone(ASTContext &C) const;
10067 void printPretty(raw_ostream &OS,
10068 const PrintingPolicy &Policy) const;
10069 const char *getSpelling() const;
10070
10071
10072 static bool classof(const Attr *A) { return A->getKind() == attr::WeakImport; }
10073};
10074
10075class WeakRefAttr : public InheritableAttr {
10076unsigned aliaseeLength;
10077char *aliasee;
10078
10079public:
10080 static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
10081 auto *A = new (Ctx) WeakRefAttr(Loc, Ctx, Aliasee, 0);
10082 A->setImplicit(true);
10083 return A;
10084 }
10085
10086 WeakRefAttr(SourceRange R, ASTContext &Ctx
10087 , llvm::StringRef Aliasee
10088 , unsigned SI
10089 )
10090 : InheritableAttr(attr::WeakRef, R, SI, false, false)
10091 , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
10092 {
10093 if (!Aliasee.empty())
10094 std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
10095 }
10096
10097 WeakRefAttr(SourceRange R, ASTContext &Ctx
10098 , unsigned SI
10099 )
10100 : InheritableAttr(attr::WeakRef, R, SI, false, false)
10101 , aliaseeLength(0),aliasee(nullptr)
10102 {
10103 }
10104
10105 WeakRefAttr *clone(ASTContext &C) const;
10106 void printPretty(raw_ostream &OS,
10107 const PrintingPolicy &Policy) const;
10108 const char *getSpelling() const;
10109 llvm::StringRef getAliasee() const {
10110 return llvm::StringRef(aliasee, aliaseeLength);
10111 }
10112 unsigned getAliaseeLength() const {
10113 return aliaseeLength;
10114 }
10115 void setAliasee(ASTContext &C, llvm::StringRef S) {
10116 aliaseeLength = S.size();
10117 this->aliasee = new (C, 1) char [aliaseeLength];
10118 if (!S.empty())
10119 std::memcpy(this->aliasee, S.data(), aliaseeLength);
10120 }
10121
10122
10123
10124 static bool classof(const Attr *A) { return A->getKind() == attr::WeakRef; }
10125};
10126
10127class WebAssemblyImportModuleAttr : public InheritableAttr {
10128unsigned importModuleLength;
10129char *importModule;
10130
10131public:
10132 static WebAssemblyImportModuleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ImportModule, SourceRange Loc = SourceRange()) {
10133 auto *A = new (Ctx) WebAssemblyImportModuleAttr(Loc, Ctx, ImportModule, 0);
10134 A->setImplicit(true);
10135 return A;
10136 }
10137
10138 WebAssemblyImportModuleAttr(SourceRange R, ASTContext &Ctx
10139 , llvm::StringRef ImportModule
10140 , unsigned SI
10141 )
10142 : InheritableAttr(attr::WebAssemblyImportModule, R, SI, false, false)
10143 , importModuleLength(ImportModule.size()),importModule(new (Ctx, 1) char[importModuleLength])
10144 {
10145 if (!ImportModule.empty())
10146 std::memcpy(importModule, ImportModule.data(), importModuleLength);
10147 }
10148
10149 WebAssemblyImportModuleAttr *clone(ASTContext &C) const;
10150 void printPretty(raw_ostream &OS,
10151 const PrintingPolicy &Policy) const;
10152 const char *getSpelling() const;
10153 llvm::StringRef getImportModule() const {
10154 return llvm::StringRef(importModule, importModuleLength);
10155 }
10156 unsigned getImportModuleLength() const {
10157 return importModuleLength;
10158 }
10159 void setImportModule(ASTContext &C, llvm::StringRef S) {
10160 importModuleLength = S.size();
10161 this->importModule = new (C, 1) char [importModuleLength];
10162 if (!S.empty())
10163 std::memcpy(this->importModule, S.data(), importModuleLength);
10164 }
10165
10166
10167
10168 static bool classof(const Attr *A) { return A->getKind() == attr::WebAssemblyImportModule; }
10169};
10170
10171class WebAssemblyImportNameAttr : public InheritableAttr {
10172unsigned importNameLength;
10173char *importName;
10174
10175public:
10176 static WebAssemblyImportNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ImportName, SourceRange Loc = SourceRange()) {
10177 auto *A = new (Ctx) WebAssemblyImportNameAttr(Loc, Ctx, ImportName, 0);
10178 A->setImplicit(true);
10179 return A;
10180 }
10181
10182 WebAssemblyImportNameAttr(SourceRange R, ASTContext &Ctx
10183 , llvm::StringRef ImportName
10184 , unsigned SI
10185 )
10186 : InheritableAttr(attr::WebAssemblyImportName, R, SI, false, false)
10187 , importNameLength(ImportName.size()),importName(new (Ctx, 1) char[importNameLength])
10188 {
10189 if (!ImportName.empty())
10190 std::memcpy(importName, ImportName.data(), importNameLength);
10191 }
10192
10193 WebAssemblyImportNameAttr *clone(ASTContext &C) const;
10194 void printPretty(raw_ostream &OS,
10195 const PrintingPolicy &Policy) const;
10196 const char *getSpelling() const;
10197 llvm::StringRef getImportName() const {
10198 return llvm::StringRef(importName, importNameLength);
10199 }
10200 unsigned getImportNameLength() const {
10201 return importNameLength;
10202 }
10203 void setImportName(ASTContext &C, llvm::StringRef S) {
10204 importNameLength = S.size();
10205 this->importName = new (C, 1) char [importNameLength];
10206 if (!S.empty())
10207 std::memcpy(this->importName, S.data(), importNameLength);
10208 }
10209
10210
10211
10212 static bool classof(const Attr *A) { return A->getKind() == attr::WebAssemblyImportName; }
10213};
10214
10215class WorkGroupSizeHintAttr : public InheritableAttr {
10216unsigned xDim;
10217
10218unsigned yDim;
10219
10220unsigned zDim;
10221
10222public:
10223 static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
10224 auto *A = new (Ctx) WorkGroupSizeHintAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
10225 A->setImplicit(true);
10226 return A;
10227 }
10228
10229 WorkGroupSizeHintAttr(SourceRange R, ASTContext &Ctx
10230 , unsigned XDim
10231 , unsigned YDim
10232 , unsigned ZDim
10233 , unsigned SI
10234 )
10235 : InheritableAttr(attr::WorkGroupSizeHint, R, SI, false, false)
10236 , xDim(XDim)
10237 , yDim(YDim)
10238 , zDim(ZDim)
10239 {
10240 }
10241
10242 WorkGroupSizeHintAttr *clone(ASTContext &C) const;
10243 void printPretty(raw_ostream &OS,
10244 const PrintingPolicy &Policy) const;
10245 const char *getSpelling() const;
10246 unsigned getXDim() const {
10247 return xDim;
10248 }
10249
10250 unsigned getYDim() const {
10251 return yDim;
10252 }
10253
10254 unsigned getZDim() const {
10255 return zDim;
10256 }
10257
10258
10259
10260 static bool classof(const Attr *A) { return A->getKind() == attr::WorkGroupSizeHint; }
10261};
10262
10263class X86ForceAlignArgPointerAttr : public InheritableAttr {
10264public:
10265 static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
10266 auto *A = new (Ctx) X86ForceAlignArgPointerAttr(Loc, Ctx, 0);
10267 A->setImplicit(true);
10268 return A;
10269 }
10270
10271 X86ForceAlignArgPointerAttr(SourceRange R, ASTContext &Ctx
10272 , unsigned SI
10273 )
10274 : InheritableAttr(attr::X86ForceAlignArgPointer, R, SI, false, false)
10275 {
10276 }
10277
10278 X86ForceAlignArgPointerAttr *clone(ASTContext &C) const;
10279 void printPretty(raw_ostream &OS,
10280 const PrintingPolicy &Policy) const;
10281 const char *getSpelling() const;
10282
10283
10284 static bool classof(const Attr *A) { return A->getKind() == attr::X86ForceAlignArgPointer; }
10285};
10286
10287class XRayInstrumentAttr : public InheritableAttr {
10288public:
10289 enum Spelling {
10290 GNU_xray_always_instrument = 0,
10291 CXX11_clang_xray_always_instrument = 1,
10292 C2x_clang_xray_always_instrument = 2,
10293 GNU_xray_never_instrument = 3,
10294 CXX11_clang_xray_never_instrument = 4,
10295 C2x_clang_xray_never_instrument = 5
10296 };
10297
10298 static XRayInstrumentAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
10299 auto *A = new (Ctx) XRayInstrumentAttr(Loc, Ctx, S);
10300 A->setImplicit(true);
10301 return A;
10302 }
10303
10304 XRayInstrumentAttr(SourceRange R, ASTContext &Ctx
10305 , unsigned SI
10306 )
10307 : InheritableAttr(attr::XRayInstrument, R, SI, false, false)
10308 {
10309 }
10310
10311 XRayInstrumentAttr *clone(ASTContext &C) const;
10312 void printPretty(raw_ostream &OS,
10313 const PrintingPolicy &Policy) const;
10314 const char *getSpelling() const;
10315 Spelling getSemanticSpelling() const {
10316 switch (SpellingListIndex) {
10317 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 10317)
;
10318 case 0: return GNU_xray_always_instrument;
10319 case 1: return CXX11_clang_xray_always_instrument;
10320 case 2: return C2x_clang_xray_always_instrument;
10321 case 3: return GNU_xray_never_instrument;
10322 case 4: return CXX11_clang_xray_never_instrument;
10323 case 5: return C2x_clang_xray_never_instrument;
10324 }
10325 }
10326 bool alwaysXRayInstrument() const { return SpellingListIndex == 0 ||
10327 SpellingListIndex == 1 ||
10328 SpellingListIndex == 2; }
10329 bool neverXRayInstrument() const { return SpellingListIndex == 3 ||
10330 SpellingListIndex == 4 ||
10331 SpellingListIndex == 5; }
10332
10333
10334 static bool classof(const Attr *A) { return A->getKind() == attr::XRayInstrument; }
10335};
10336
10337class XRayLogArgsAttr : public InheritableAttr {
10338unsigned argumentCount;
10339
10340public:
10341 static XRayLogArgsAttr *CreateImplicit(ASTContext &Ctx, unsigned ArgumentCount, SourceRange Loc = SourceRange()) {
10342 auto *A = new (Ctx) XRayLogArgsAttr(Loc, Ctx, ArgumentCount, 0);
10343 A->setImplicit(true);
10344 return A;
10345 }
10346
10347 XRayLogArgsAttr(SourceRange R, ASTContext &Ctx
10348 , unsigned ArgumentCount
10349 , unsigned SI
10350 )
10351 : InheritableAttr(attr::XRayLogArgs, R, SI, false, false)
10352 , argumentCount(ArgumentCount)
10353 {
10354 }
10355
10356 XRayLogArgsAttr *clone(ASTContext &C) const;
10357 void printPretty(raw_ostream &OS,
10358 const PrintingPolicy &Policy) const;
10359 const char *getSpelling() const;
10360 unsigned getArgumentCount() const {
10361 return argumentCount;
10362 }
10363
10364
10365
10366 static bool classof(const Attr *A) { return A->getKind() == attr::XRayLogArgs; }
10367};
10368
10369#endif // LLVM_CLANG_ATTR_CLASSES_INC