Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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

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

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

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

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