Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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

/build/llvm-toolchain-snapshot-7~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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 bool IsMV = false;
1589
1590 if (Overloads) {
1591 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1592 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1593 OverloadSet.addDecl(*it);
1594
1595 // Check whether the function is a non-template, non-member which takes no
1596 // arguments.
1597 if (IsMemExpr)
1598 continue;
1599 if (const FunctionDecl *OverloadDecl
1600 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1601 if (OverloadDecl->getMinRequiredArguments() == 0) {
1602 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1603 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1604 OverloadDecl->isCPUSpecificMultiVersion()))) {
1605 ZeroArgCallReturnTy = QualType();
1606 Ambiguous = true;
1607 } else {
1608 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1609 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1610 OverloadDecl->isCPUSpecificMultiVersion();
1611 }
1612 }
1613 }
1614 }
1615
1616 // If it's not a member, use better machinery to try to resolve the call
1617 if (!IsMemExpr)
1618 return !ZeroArgCallReturnTy.isNull();
1619 }
1620
1621 // Attempt to call the member with no arguments - this will correctly handle
1622 // member templates with defaults/deduction of template arguments, overloads
1623 // with default arguments, etc.
1624 if (IsMemExpr && !E.isTypeDependent()) {
1625 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1626 getDiagnostics().setSuppressAllDiagnostics(true);
1627 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1628 None, SourceLocation());
1629 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1630 if (R.isUsable()) {
1631 ZeroArgCallReturnTy = R.get()->getType();
1632 return true;
1633 }
1634 return false;
1635 }
1636
1637 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1638 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1639 if (Fun->getMinRequiredArguments() == 0)
1640 ZeroArgCallReturnTy = Fun->getReturnType();
1641 return true;
1642 }
1643 }
1644
1645 // We don't have an expression that's convenient to get a FunctionDecl from,
1646 // but we can at least check if the type is "function of 0 arguments".
1647 QualType ExprTy = E.getType();
1648 const FunctionType *FunTy = nullptr;
1649 QualType PointeeTy = ExprTy->getPointeeType();
1650 if (!PointeeTy.isNull())
1651 FunTy = PointeeTy->getAs<FunctionType>();
1652 if (!FunTy)
1653 FunTy = ExprTy->getAs<FunctionType>();
1654
1655 if (const FunctionProtoType *FPT =
1656 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1657 if (FPT->getNumParams() == 0)
1658 ZeroArgCallReturnTy = FunTy->getReturnType();
1659 return true;
1660 }
1661 return false;
1662}
1663
1664/// Give notes for a set of overloads.
1665///
1666/// A companion to tryExprAsCall. In cases when the name that the programmer
1667/// wrote was an overloaded function, we may be able to make some guesses about
1668/// plausible overloads based on their return types; such guesses can be handed
1669/// off to this method to be emitted as notes.
1670///
1671/// \param Overloads - The overloads to note.
1672/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1673/// -fshow-overloads=best, this is the location to attach to the note about too
1674/// many candidates. Typically this will be the location of the original
1675/// ill-formed expression.
1676static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1677 const SourceLocation FinalNoteLoc) {
1678 int ShownOverloads = 0;
1679 int SuppressedOverloads = 0;
1680 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1681 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1682 // FIXME: Magic number for max shown overloads stolen from
1683 // OverloadCandidateSet::NoteCandidates.
1684 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1685 ++SuppressedOverloads;
1686 continue;
1687 }
1688
1689 NamedDecl *Fn = (*It)->getUnderlyingDecl();
1690 // Don't print overloads for non-default multiversioned functions.
1691 if (const auto *FD = Fn->getAsFunction()) {
1692 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1693 !FD->getAttr<TargetAttr>()->isDefaultVersion())
1694 continue;
1695 }
1696 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1697 ++ShownOverloads;
1698 }
1699
1700 if (SuppressedOverloads)
1701 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1702 << SuppressedOverloads;
1703}
1704
1705static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1706 const UnresolvedSetImpl &Overloads,
1707 bool (*IsPlausibleResult)(QualType)) {
1708 if (!IsPlausibleResult)
1709 return noteOverloads(S, Overloads, Loc);
1710
1711 UnresolvedSet<2> PlausibleOverloads;
1712 for (OverloadExpr::decls_iterator It = Overloads.begin(),
1713 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1714 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1715 QualType OverloadResultTy = OverloadDecl->getReturnType();
1716 if (IsPlausibleResult(OverloadResultTy))
1717 PlausibleOverloads.addDecl(It.getDecl());
1718 }
1719 noteOverloads(S, PlausibleOverloads, Loc);
1720}
1721
1722/// Determine whether the given expression can be called by just
1723/// putting parentheses after it. Notably, expressions with unary
1724/// operators can't be because the unary operator will start parsing
1725/// outside the call.
1726static bool IsCallableWithAppend(Expr *E) {
1727 E = E->IgnoreImplicit();
1728 return (!isa<CStyleCastExpr>(E) &&
1729 !isa<UnaryOperator>(E) &&
1730 !isa<BinaryOperator>(E) &&
1731 !isa<CXXOperatorCallExpr>(E));
1732}
1733
1734static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
1735 if (const auto *UO = dyn_cast<UnaryOperator>(E))
1736 E = UO->getSubExpr();
1737
1738 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1739 if (ULE->getNumDecls() == 0)
1740 return false;
1741
1742 const NamedDecl *ND = *ULE->decls_begin();
1743 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1744 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1745 }
1746 return false;
1747}
1748
1749bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1750 bool ForceComplain,
1751 bool (*IsPlausibleResult)(QualType)) {
1752 SourceLocation Loc = E.get()->getExprLoc();
1753 SourceRange Range = E.get()->getSourceRange();
1754
1755 QualType ZeroArgCallTy;
1756 UnresolvedSet<4> Overloads;
1757 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1758 !ZeroArgCallTy.isNull() &&
1759 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1760 // At this point, we know E is potentially callable with 0
1761 // arguments and that it returns something of a reasonable type,
1762 // so we can emit a fixit and carry on pretending that E was
1763 // actually a CallExpr.
1764 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1765 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1766 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1767 << (IsCallableWithAppend(E.get())
1768 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1769 : FixItHint());
1770 if (!IsMV)
1771 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1772
1773 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1774 // while doing so.
1775 E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1776 Range.getEnd().getLocWithOffset(1));
1777 return true;
1778 }
1779
1780 if (!ForceComplain) return false;
1781
1782 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1783 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1784 if (!IsMV)
1785 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1786 E = ExprError();
1787 return true;
1788}
1789
1790IdentifierInfo *Sema::getSuperIdentifier() const {
1791 if (!Ident_super)
1792 Ident_super = &Context.Idents.get("super");
1793 return Ident_super;
1794}
1795
1796IdentifierInfo *Sema::getFloat128Identifier() const {
1797 if (!Ident___float128)
1798 Ident___float128 = &Context.Idents.get("__float128");
1799 return Ident___float128;
1800}
1801
1802void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
1803 CapturedRegionKind K) {
1804 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
1805 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1806 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1807 CSI->ReturnType = Context.VoidTy;
1808 FunctionScopes.push_back(CSI);
1809}
1810
1811CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1812 if (FunctionScopes.empty())
1813 return nullptr;
1814
1815 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1816}
1817
1818const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1819Sema::getMismatchingDeleteExpressions() const {
1820 return DeleteExprs;
1821}
1822
1823void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1824 if (ExtStr.empty())
1825 return;
1826 llvm::SmallVector<StringRef, 1> Exts;
1827 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1828 auto CanT = T.getCanonicalType().getTypePtr();
1829 for (auto &I : Exts)
1830 OpenCLTypeExtMap[CanT].insert(I.str());
1831}
1832
1833void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1834 llvm::SmallVector<StringRef, 1> Exts;
1835 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1836 if (Exts.empty())
1837 return;
1838 for (auto &I : Exts)
1839 OpenCLDeclExtMap[FD].insert(I.str());
1840}
1841
1842void Sema::setCurrentOpenCLExtensionForType(QualType T) {
1843 if (CurrOpenCLExtension.empty())
1844 return;
1845 setOpenCLExtensionForType(T, CurrOpenCLExtension);
1846}
1847
1848void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
1849 if (CurrOpenCLExtension.empty())
1850 return;
1851 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1852}
1853
1854bool Sema::isOpenCLDisabledDecl(Decl *FD) {
1855 auto Loc = OpenCLDeclExtMap.find(FD);
1856 if (Loc == OpenCLDeclExtMap.end())
1857 return false;
1858 for (auto &I : Loc->second) {
1859 if (!getOpenCLOptions().isEnabled(I))
1860 return true;
1861 }
1862 return false;
1863}
1864
1865template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1866bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1867 DiagInfoT DiagInfo, MapT &Map,
1868 unsigned Selector,
1869 SourceRange SrcRange) {
1870 auto Loc = Map.find(D);
1871 if (Loc == Map.end())
1872 return false;
1873 bool Disabled = false;
1874 for (auto &I : Loc->second) {
1875 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1876 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1877 << I << SrcRange;
1878 Disabled = true;
1879 }
1880 }
1881 return Disabled;
1882}
1883
1884bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
1885 // Check extensions for declared types.
1886 Decl *Decl = nullptr;
1887 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1888 Decl = TypedefT->getDecl();
1889 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1890 Decl = TagT->getDecl();
1891 auto Loc = DS.getTypeSpecTypeLoc();
1892 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
1893 return true;
1894
1895 // Check extensions for builtin types.
1896 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
1897 QT, OpenCLTypeExtMap);
1898}
1899
1900bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
1901 IdentifierInfo *FnName = D.getIdentifier();
1902 return checkOpenCLDisabledTypeOrDecl(&D, E.getLocStart(), FnName,
1903 OpenCLDeclExtMap, 1, D.getSourceRange());
1904}

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

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