Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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

/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

1//===-- PDBASTParser.cpp ----------------------------------------*- C++ -*-===//
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#include "PDBASTParser.h"
11
12#include "SymbolFilePDB.h"
13
14#include "clang/AST/CharUnits.h"
15#include "clang/AST/Decl.h"
16#include "clang/AST/DeclCXX.h"
17
18#include "lldb/Core/Module.h"
19#include "lldb/Symbol/ClangASTContext.h"
20#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
21#include "lldb/Symbol/ClangUtil.h"
22#include "lldb/Symbol/Declaration.h"
23#include "lldb/Symbol/SymbolFile.h"
24#include "lldb/Symbol/TypeMap.h"
25#include "lldb/Symbol/TypeSystem.h"
26
27#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
28#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
29#include "llvm/DebugInfo/PDB/PDBSymbol.h"
30#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
31#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
32#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
33#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
34#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
35#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
36#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
37#include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
38#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
39#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
40
41using namespace lldb;
42using namespace lldb_private;
43using namespace llvm::pdb;
44
45static int TranslateUdtKind(PDB_UdtType pdb_kind) {
46 switch (pdb_kind) {
47 case PDB_UdtType::Class:
48 return clang::TTK_Class;
49 case PDB_UdtType::Struct:
50 return clang::TTK_Struct;
51 case PDB_UdtType::Union:
52 return clang::TTK_Union;
53 case PDB_UdtType::Interface:
54 return clang::TTK_Interface;
55 }
56 llvm_unreachable("unsuported PDB UDT type")::llvm::llvm_unreachable_internal("unsuported PDB UDT type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 56)
;
57}
58
59static lldb::Encoding TranslateBuiltinEncoding(PDB_BuiltinType type) {
60 switch (type) {
61 case PDB_BuiltinType::Float:
62 return lldb::eEncodingIEEE754;
63 case PDB_BuiltinType::Int:
64 case PDB_BuiltinType::Long:
65 case PDB_BuiltinType::Char:
66 return lldb::eEncodingSint;
67 case PDB_BuiltinType::Bool:
68 case PDB_BuiltinType::Char16:
69 case PDB_BuiltinType::Char32:
70 case PDB_BuiltinType::UInt:
71 case PDB_BuiltinType::ULong:
72 case PDB_BuiltinType::HResult:
73 case PDB_BuiltinType::WCharT:
74 return lldb::eEncodingUint;
75 default:
76 return lldb::eEncodingInvalid;
77 }
78}
79
80static lldb::Encoding TranslateEnumEncoding(PDB_VariantType type) {
81 switch (type) {
82 case PDB_VariantType::Int8:
83 case PDB_VariantType::Int16:
84 case PDB_VariantType::Int32:
85 case PDB_VariantType::Int64:
86 return lldb::eEncodingSint;
87
88 case PDB_VariantType::UInt8:
89 case PDB_VariantType::UInt16:
90 case PDB_VariantType::UInt32:
91 case PDB_VariantType::UInt64:
92 return lldb::eEncodingUint;
93
94 default:
95 break;
96 }
97
98 return lldb::eEncodingSint;
99}
100
101static CompilerType
102GetBuiltinTypeForPDBEncodingAndBitSize(ClangASTContext &clang_ast,
103 const PDBSymbolTypeBuiltin &pdb_type,
104 Encoding encoding, uint32_t width) {
105 auto *ast = clang_ast.getASTContext();
106 if (!ast)
107 return CompilerType();
108
109 switch (pdb_type.getBuiltinType()) {
110 default:
111 break;
112 case PDB_BuiltinType::None:
113 return CompilerType();
114 case PDB_BuiltinType::Void:
115 return clang_ast.GetBasicType(eBasicTypeVoid);
116 case PDB_BuiltinType::Char:
117 return clang_ast.GetBasicType(eBasicTypeChar);
118 case PDB_BuiltinType::Bool:
119 return clang_ast.GetBasicType(eBasicTypeBool);
120 case PDB_BuiltinType::Long:
121 if (width == ast->getTypeSize(ast->LongTy))
122 return CompilerType(ast, ast->LongTy);
123 if (width == ast->getTypeSize(ast->LongLongTy))
124 return CompilerType(ast, ast->LongLongTy);
125 break;
126 case PDB_BuiltinType::ULong:
127 if (width == ast->getTypeSize(ast->UnsignedLongTy))
128 return CompilerType(ast, ast->UnsignedLongTy);
129 if (width == ast->getTypeSize(ast->UnsignedLongLongTy))
130 return CompilerType(ast, ast->UnsignedLongLongTy);
131 break;
132 case PDB_BuiltinType::WCharT:
133 if (width == ast->getTypeSize(ast->WCharTy))
134 return CompilerType(ast, ast->WCharTy);
135 break;
136 case PDB_BuiltinType::Char16:
137 return CompilerType(ast, ast->Char16Ty);
138 case PDB_BuiltinType::Char32:
139 return CompilerType(ast, ast->Char32Ty);
140 case PDB_BuiltinType::Float:
141 // Note: types `long double` and `double` have same bit size in MSVC and
142 // there is no information in the PDB to distinguish them. So when falling
143 // back to default search, the compiler type of `long double` will be
144 // represented by the one generated for `double`.
145 break;
146 }
147 // If there is no match on PDB_BuiltinType, fall back to default search by
148 // encoding and width only
149 return clang_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, width);
150}
151
152static ConstString GetPDBBuiltinTypeName(const PDBSymbolTypeBuiltin &pdb_type,
153 CompilerType &compiler_type) {
154 PDB_BuiltinType kind = pdb_type.getBuiltinType();
155 switch (kind) {
156 default:
157 break;
158 case PDB_BuiltinType::Currency:
159 return ConstString("CURRENCY");
160 case PDB_BuiltinType::Date:
161 return ConstString("DATE");
162 case PDB_BuiltinType::Variant:
163 return ConstString("VARIANT");
164 case PDB_BuiltinType::Complex:
165 return ConstString("complex");
166 case PDB_BuiltinType::Bitfield:
167 return ConstString("bitfield");
168 case PDB_BuiltinType::BSTR:
169 return ConstString("BSTR");
170 case PDB_BuiltinType::HResult:
171 return ConstString("HRESULT");
172 case PDB_BuiltinType::BCD:
173 return ConstString("BCD");
174 case PDB_BuiltinType::Char16:
175 return ConstString("char16_t");
176 case PDB_BuiltinType::Char32:
177 return ConstString("char32_t");
178 case PDB_BuiltinType::None:
179 return ConstString("...");
180 }
181 return compiler_type.GetTypeName();
182}
183
184static bool GetDeclarationForSymbol(const PDBSymbol &symbol,
185 Declaration &decl) {
186 auto &raw_sym = symbol.getRawSymbol();
187 auto first_line_up = raw_sym.getSrcLineOnTypeDefn();
188
189 if (!first_line_up) {
190 auto lines_up = symbol.getSession().findLineNumbersByAddress(
191 raw_sym.getVirtualAddress(), raw_sym.getLength());
192 if (!lines_up)
193 return false;
194 first_line_up = lines_up->getNext();
195 if (!first_line_up)
196 return false;
197 }
198 uint32_t src_file_id = first_line_up->getSourceFileId();
199 auto src_file_up = symbol.getSession().getSourceFileById(src_file_id);
200 if (!src_file_up)
201 return false;
202
203 FileSpec spec(src_file_up->getFileName(), /*resolve_path*/ false);
204 decl.SetFile(spec);
205 decl.SetColumn(first_line_up->getColumnNumber());
206 decl.SetLine(first_line_up->getLineNumber());
207 return true;
208}
209
210static AccessType TranslateMemberAccess(PDB_MemberAccess access) {
211 switch (access) {
212 case PDB_MemberAccess::Private:
213 return eAccessPrivate;
214 case PDB_MemberAccess::Protected:
215 return eAccessProtected;
216 case PDB_MemberAccess::Public:
217 return eAccessPublic;
218 }
219 return eAccessNone;
220}
221
222static AccessType GetDefaultAccessibilityForUdtKind(PDB_UdtType udt_kind) {
223 switch (udt_kind) {
224 case PDB_UdtType::Struct:
225 case PDB_UdtType::Union:
226 return eAccessPublic;
227 case PDB_UdtType::Class:
228 case PDB_UdtType::Interface:
229 return eAccessPrivate;
230 }
231 llvm_unreachable("unsupported PDB UDT type")::llvm::llvm_unreachable_internal("unsupported PDB UDT type",
"/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 231)
;
232}
233
234static AccessType GetAccessibilityForUdt(const PDBSymbolTypeUDT &udt) {
235 AccessType access = TranslateMemberAccess(udt.getAccess());
236 if (access != lldb::eAccessNone || !udt.isNested())
237 return access;
238
239 auto parent = udt.getClassParent();
240 if (!parent)
241 return lldb::eAccessNone;
242
243 auto parent_udt = llvm::dyn_cast<PDBSymbolTypeUDT>(parent.get());
244 if (!parent_udt)
245 return lldb::eAccessNone;
246
247 return GetDefaultAccessibilityForUdtKind(parent_udt->getUdtKind());
248}
249
250static clang::MSInheritanceAttr::Spelling
251GetMSInheritance(const PDBSymbolTypeUDT &udt) {
252 int base_count = 0;
253 bool has_virtual = false;
254
255 auto bases_enum = udt.findAllChildren<PDBSymbolTypeBaseClass>();
256 if (bases_enum) {
257 while (auto base = bases_enum->getNext()) {
258 base_count++;
259 has_virtual |= base->isVirtualBaseClass();
260 }
261 }
262
263 if (has_virtual)
264 return clang::MSInheritanceAttr::Keyword_virtual_inheritance;
265 if (base_count > 1)
266 return clang::MSInheritanceAttr::Keyword_multiple_inheritance;
267 return clang::MSInheritanceAttr::Keyword_single_inheritance;
268}
269
270static std::unique_ptr<llvm::pdb::PDBSymbol>
271GetClassOrFunctionParent(const llvm::pdb::PDBSymbol &symbol) {
272 const IPDBSession &session = symbol.getSession();
273 const IPDBRawSymbol &raw = symbol.getRawSymbol();
274 auto tag = symbol.getSymTag();
275
276 // For items that are nested inside of a class, return the class that it is
277 // nested inside of.
278 // Note that only certain items can be nested inside of classes.
279 switch (tag) {
280 case PDB_SymType::Function:
281 case PDB_SymType::Data:
282 case PDB_SymType::UDT:
283 case PDB_SymType::Enum:
284 case PDB_SymType::FunctionSig:
285 case PDB_SymType::Typedef:
286 case PDB_SymType::BaseClass:
287 case PDB_SymType::VTable: {
288 auto class_parent_id = raw.getClassParentId();
289 if (auto class_parent = session.getSymbolById(class_parent_id))
290 return class_parent;
291 }
292 default:
293 break;
294 }
295
296 // Otherwise, if it is nested inside of a function, return the function.
297 // Note that only certain items can be nested inside of functions.
298 switch (tag) {
299 case PDB_SymType::Block:
300 case PDB_SymType::Data: {
301 auto lexical_parent_id = raw.getLexicalParentId();
302 auto lexical_parent = session.getSymbolById(lexical_parent_id);
303 if (!lexical_parent)
304 return nullptr;
305
306 auto lexical_parent_tag = lexical_parent->getSymTag();
307 if (lexical_parent_tag == PDB_SymType::Function)
308 return lexical_parent;
309 if (lexical_parent_tag == PDB_SymType::Exe)
310 return nullptr;
311
312 return GetClassOrFunctionParent(*lexical_parent);
313 }
314 default:
315 return nullptr;
316 }
317}
318
319static clang::NamedDecl *
320GetDeclFromContextByName(const clang::ASTContext &ast,
321 const clang::DeclContext &decl_context,
322 llvm::StringRef name) {
323 clang::IdentifierInfo &ident = ast.Idents.get(name);
324 clang::DeclarationName decl_name = ast.DeclarationNames.getIdentifier(&ident);
325 clang::DeclContext::lookup_result result = decl_context.lookup(decl_name);
326 if (result.empty())
327 return nullptr;
328
329 return result[0];
330}
331
332static bool IsAnonymousNamespaceName(const std::string &name) {
333 return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
334}
335
336static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc) {
337 switch (pdb_cc) {
338 case llvm::codeview::CallingConvention::NearC:
339 return clang::CC_C;
340 case llvm::codeview::CallingConvention::NearStdCall:
341 return clang::CC_X86StdCall;
342 case llvm::codeview::CallingConvention::NearFast:
343 return clang::CC_X86FastCall;
344 case llvm::codeview::CallingConvention::ThisCall:
345 return clang::CC_X86ThisCall;
346 case llvm::codeview::CallingConvention::NearVector:
347 return clang::CC_X86VectorCall;
348 case llvm::codeview::CallingConvention::NearPascal:
349 return clang::CC_X86Pascal;
350 default:
351 assert(false && "Unknown calling convention")((false && "Unknown calling convention") ? static_cast
<void> (0) : __assert_fail ("false && \"Unknown calling convention\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 351, __PRETTY_FUNCTION__))
;
352 return clang::CC_C;
353 }
354}
355
356PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast) {}
357
358PDBASTParser::~PDBASTParser() {}
359
360// DebugInfoASTParser interface
361
362lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
363 Declaration decl;
364 switch (type.getSymTag()) {
1
Control jumps to 'case UDT:' at line 373
365 case PDB_SymType::BaseClass: {
366 auto symbol_file = m_ast.GetSymbolFile();
367 if (!symbol_file)
368 return nullptr;
369
370 auto ty = symbol_file->ResolveTypeUID(type.getRawSymbol().getTypeId());
371 return ty ? ty->shared_from_this() : nullptr;
372 } break;
373 case PDB_SymType::UDT: {
374 auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&type);
375 assert(udt)((udt) ? static_cast<void> (0) : __assert_fail ("udt", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 375, __PRETTY_FUNCTION__))
;
376
377 // Note that, unnamed UDT being typedef-ed is generated as a UDT symbol
378 // other than a Typedef symbol in PDB. For example,
379 // typedef union { short Row; short Col; } Union;
380 // is generated as a named UDT in PDB:
381 // union Union { short Row; short Col; }
382 // Such symbols will be handled here.
383
384 // Some UDT with trival ctor has zero length. Just ignore.
385 if (udt->getLength() == 0)
2
Assuming the condition is false
3
Taking false branch
386 return nullptr;
387
388 // Ignore unnamed-tag UDTs.
389 auto name = PDBNameDropScope(udt->getName());
390 if (name.empty())
4
Assuming the condition is false
5
Taking false branch
391 return nullptr;
392
393 auto decl_context = GetDeclContextContainingSymbol(type);
394
395 // Check if such an UDT already exists in the current context.
396 // This may occur with const or volatile types. There are separate type
397 // symbols in PDB for types with const or volatile modifiers, but we need
398 // to create only one declaration for them all.
399 Type::ResolveStateTag type_resolve_state_tag;
400 CompilerType clang_type = m_ast.GetTypeForIdentifier<clang::CXXRecordDecl>(
401 ConstString(name), decl_context);
402 if (!clang_type.IsValid()) {
6
Taking true branch
403 auto access = GetAccessibilityForUdt(*udt);
404
405 auto tag_type_kind = TranslateUdtKind(udt->getUdtKind());
406
407 ClangASTMetadata metadata;
408 metadata.SetUserID(type.getSymIndexId());
409 metadata.SetIsDynamicCXXType(false);
410
411 clang_type = m_ast.CreateRecordType(
412 decl_context, access, name.c_str(), tag_type_kind,
413 lldb::eLanguageTypeC_plus_plus, &metadata);
414 assert(clang_type.IsValid())((clang_type.IsValid()) ? static_cast<void> (0) : __assert_fail
("clang_type.IsValid()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 414, __PRETTY_FUNCTION__))
;
415
416 auto record_decl =
417 m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
418 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 418, __PRETTY_FUNCTION__))
;
419 m_uid_to_decl[type.getSymIndexId()] = record_decl;
420
421 auto inheritance_attr = clang::MSInheritanceAttr::CreateImplicit(
7
Calling 'MSInheritanceAttr::CreateImplicit'
422 *m_ast.getASTContext(), GetMSInheritance(*udt));
423 record_decl->addAttr(inheritance_attr);
424
425 ClangASTContext::StartTagDeclarationDefinition(clang_type);
426
427 auto children = udt->findAllChildren();
428 if (!children || children->getChildCount() == 0) {
429 // PDB does not have symbol of forwarder. We assume we get an udt w/o
430 // any fields. Just complete it at this point.
431 ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
432
433 ClangASTContext::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
434 false);
435
436 type_resolve_state_tag = Type::eResolveStateFull;
437 } else {
438 // Add the type to the forward declarations. It will help us to avoid
439 // an endless recursion in CompleteTypeFromUdt function.
440 m_forward_decl_to_uid[record_decl] = type.getSymIndexId();
441
442 ClangASTContext::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
443 true);
444
445 type_resolve_state_tag = Type::eResolveStateForward;
446 }
447 } else
448 type_resolve_state_tag = Type::eResolveStateForward;
449
450 if (udt->isConstType())
451 clang_type = clang_type.AddConstModifier();
452
453 if (udt->isVolatileType())
454 clang_type = clang_type.AddVolatileModifier();
455
456 GetDeclarationForSymbol(type, decl);
457 return std::make_shared<lldb_private::Type>(
458 type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
459 udt->getLength(), nullptr, LLDB_INVALID_UID(18446744073709551615UL),
460 lldb_private::Type::eEncodingIsUID, decl, clang_type,
461 type_resolve_state_tag);
462 } break;
463 case PDB_SymType::Enum: {
464 auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type);
465 assert(enum_type)((enum_type) ? static_cast<void> (0) : __assert_fail ("enum_type"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 465, __PRETTY_FUNCTION__))
;
466
467 std::string name = PDBNameDropScope(enum_type->getName());
468 auto decl_context = GetDeclContextContainingSymbol(type);
469 uint64_t bytes = enum_type->getLength();
470
471 // Check if such an enum already exists in the current context
472 CompilerType ast_enum = m_ast.GetTypeForIdentifier<clang::EnumDecl>(
473 ConstString(name), decl_context);
474 if (!ast_enum.IsValid()) {
475 auto underlying_type_up = enum_type->getUnderlyingType();
476 if (!underlying_type_up)
477 return nullptr;
478
479 lldb::Encoding encoding =
480 TranslateBuiltinEncoding(underlying_type_up->getBuiltinType());
481 // FIXME: Type of underlying builtin is always `Int`. We correct it with
482 // the very first enumerator's encoding if any.
483 auto first_child = enum_type->findOneChild<PDBSymbolData>();
484 if (first_child)
485 encoding = TranslateEnumEncoding(first_child->getValue().Type);
486
487 CompilerType builtin_type;
488 if (bytes > 0)
489 builtin_type = GetBuiltinTypeForPDBEncodingAndBitSize(
490 m_ast, *underlying_type_up, encoding, bytes * 8);
491 else
492 builtin_type = m_ast.GetBasicType(eBasicTypeInt);
493
494 // FIXME: PDB does not have information about scoped enumeration (Enum
495 // Class). Set it false for now.
496 bool isScoped = false;
497
498 ast_enum = m_ast.CreateEnumerationType(name.c_str(), decl_context, decl,
499 builtin_type, isScoped);
500
501 auto enum_decl = ClangASTContext::GetAsEnumDecl(ast_enum);
502 assert(enum_decl)((enum_decl) ? static_cast<void> (0) : __assert_fail ("enum_decl"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 502, __PRETTY_FUNCTION__))
;
503 m_uid_to_decl[type.getSymIndexId()] = enum_decl;
504
505 auto enum_values = enum_type->findAllChildren<PDBSymbolData>();
506 if (enum_values) {
507 while (auto enum_value = enum_values->getNext()) {
508 if (enum_value->getDataKind() != PDB_DataKind::Constant)
509 continue;
510 AddEnumValue(ast_enum, *enum_value);
511 }
512 }
513
514 if (ClangASTContext::StartTagDeclarationDefinition(ast_enum))
515 ClangASTContext::CompleteTagDeclarationDefinition(ast_enum);
516 }
517
518 if (enum_type->isConstType())
519 ast_enum = ast_enum.AddConstModifier();
520
521 if (enum_type->isVolatileType())
522 ast_enum = ast_enum.AddVolatileModifier();
523
524 GetDeclarationForSymbol(type, decl);
525 return std::make_shared<lldb_private::Type>(
526 type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), bytes,
527 nullptr, LLDB_INVALID_UID(18446744073709551615UL), lldb_private::Type::eEncodingIsUID, decl,
528 ast_enum, lldb_private::Type::eResolveStateFull);
529 } break;
530 case PDB_SymType::Typedef: {
531 auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type);
532 assert(type_def)((type_def) ? static_cast<void> (0) : __assert_fail ("type_def"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 532, __PRETTY_FUNCTION__))
;
533
534 lldb_private::Type *target_type =
535 m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId());
536 if (!target_type)
537 return nullptr;
538
539 std::string name = PDBNameDropScope(type_def->getName());
540 auto decl_ctx = GetDeclContextContainingSymbol(type);
541
542 // Check if such a typedef already exists in the current context
543 CompilerType ast_typedef =
544 m_ast.GetTypeForIdentifier<clang::TypedefNameDecl>(ConstString(name),
545 decl_ctx);
546 if (!ast_typedef.IsValid()) {
547 CompilerType target_ast_type = target_type->GetFullCompilerType();
548
549 ast_typedef = m_ast.CreateTypedefType(
550 target_ast_type, name.c_str(), CompilerDeclContext(&m_ast, decl_ctx));
551 if (!ast_typedef)
552 return nullptr;
553
554 auto typedef_decl = ClangASTContext::GetAsTypedefDecl(ast_typedef);
555 assert(typedef_decl)((typedef_decl) ? static_cast<void> (0) : __assert_fail
("typedef_decl", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 555, __PRETTY_FUNCTION__))
;
556 m_uid_to_decl[type.getSymIndexId()] = typedef_decl;
557 }
558
559 if (type_def->isConstType())
560 ast_typedef = ast_typedef.AddConstModifier();
561
562 if (type_def->isVolatileType())
563 ast_typedef = ast_typedef.AddVolatileModifier();
564
565 GetDeclarationForSymbol(type, decl);
566 return std::make_shared<lldb_private::Type>(
567 type_def->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
568 type_def->getLength(), nullptr, target_type->GetID(),
569 lldb_private::Type::eEncodingIsTypedefUID, decl, ast_typedef,
570 lldb_private::Type::eResolveStateFull);
571 } break;
572 case PDB_SymType::Function:
573 case PDB_SymType::FunctionSig: {
574 std::string name;
575 PDBSymbolTypeFunctionSig *func_sig = nullptr;
576 if (auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(&type)) {
577 if (pdb_func->isCompilerGenerated())
578 return nullptr;
579
580 auto sig = pdb_func->getSignature();
581 if (!sig)
582 return nullptr;
583 func_sig = sig.release();
584 // Function type is named.
585 name = PDBNameDropScope(pdb_func->getName());
586 } else if (auto pdb_func_sig =
587 llvm::dyn_cast<PDBSymbolTypeFunctionSig>(&type)) {
588 func_sig = const_cast<PDBSymbolTypeFunctionSig *>(pdb_func_sig);
589 } else
590 llvm_unreachable("Unexpected PDB symbol!")::llvm::llvm_unreachable_internal("Unexpected PDB symbol!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 590)
;
591
592 auto arg_enum = func_sig->getArguments();
593 uint32_t num_args = arg_enum->getChildCount();
594 std::vector<CompilerType> arg_list;
595
596 bool is_variadic = func_sig->isCVarArgs();
597 // Drop last variadic argument.
598 if (is_variadic)
599 --num_args;
600 for (uint32_t arg_idx = 0; arg_idx < num_args; arg_idx++) {
601 auto arg = arg_enum->getChildAtIndex(arg_idx);
602 if (!arg)
603 break;
604 lldb_private::Type *arg_type =
605 m_ast.GetSymbolFile()->ResolveTypeUID(arg->getSymIndexId());
606 // If there's some error looking up one of the dependent types of this
607 // function signature, bail.
608 if (!arg_type)
609 return nullptr;
610 CompilerType arg_ast_type = arg_type->GetFullCompilerType();
611 arg_list.push_back(arg_ast_type);
612 }
613 lldbassert(arg_list.size() <= num_args)lldb_private::lldb_assert(static_cast<bool>(arg_list.size
() <= num_args), "arg_list.size() <= num_args", __FUNCTION__
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 613)
;
614
615 auto pdb_return_type = func_sig->getReturnType();
616 lldb_private::Type *return_type =
617 m_ast.GetSymbolFile()->ResolveTypeUID(pdb_return_type->getSymIndexId());
618 // If there's some error looking up one of the dependent types of this
619 // function signature, bail.
620 if (!return_type)
621 return nullptr;
622 CompilerType return_ast_type = return_type->GetFullCompilerType();
623 uint32_t type_quals = 0;
624 if (func_sig->isConstType())
625 type_quals |= clang::Qualifiers::Const;
626 if (func_sig->isVolatileType())
627 type_quals |= clang::Qualifiers::Volatile;
628 auto cc = TranslateCallingConvention(func_sig->getCallingConvention());
629 CompilerType func_sig_ast_type =
630 m_ast.CreateFunctionType(return_ast_type, arg_list.data(),
631 arg_list.size(), is_variadic, type_quals, cc);
632
633 GetDeclarationForSymbol(type, decl);
634 return std::make_shared<lldb_private::Type>(
635 type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), 0,
636 nullptr, LLDB_INVALID_UID(18446744073709551615UL), lldb_private::Type::eEncodingIsUID, decl,
637 func_sig_ast_type, lldb_private::Type::eResolveStateFull);
638 } break;
639 case PDB_SymType::ArrayType: {
640 auto array_type = llvm::dyn_cast<PDBSymbolTypeArray>(&type);
641 assert(array_type)((array_type) ? static_cast<void> (0) : __assert_fail (
"array_type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 641, __PRETTY_FUNCTION__))
;
642 uint32_t num_elements = array_type->getCount();
643 uint32_t element_uid = array_type->getElementTypeId();
644 uint32_t bytes = array_type->getLength();
645
646 // If array rank > 0, PDB gives the element type at N=0. So element type
647 // will parsed in the order N=0, N=1,..., N=rank sequentially.
648 lldb_private::Type *element_type =
649 m_ast.GetSymbolFile()->ResolveTypeUID(element_uid);
650 if (!element_type)
651 return nullptr;
652
653 CompilerType element_ast_type = element_type->GetForwardCompilerType();
654 // If element type is UDT, it needs to be complete.
655 if (ClangASTContext::IsCXXClassType(element_ast_type) &&
656 element_ast_type.GetCompleteType() == false) {
657 if (ClangASTContext::StartTagDeclarationDefinition(element_ast_type)) {
658 ClangASTContext::CompleteTagDeclarationDefinition(element_ast_type);
659 } else {
660 // We are not able to start defintion.
661 return nullptr;
662 }
663 }
664 CompilerType array_ast_type = m_ast.CreateArrayType(
665 element_ast_type, num_elements, /*is_gnu_vector*/ false);
666 TypeSP type_sp = std::make_shared<lldb_private::Type>(
667 array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
668 bytes, nullptr, LLDB_INVALID_UID(18446744073709551615UL), lldb_private::Type::eEncodingIsUID,
669 decl, array_ast_type, lldb_private::Type::eResolveStateFull);
670 type_sp->SetEncodingType(element_type);
671 return type_sp;
672 } break;
673 case PDB_SymType::BuiltinType: {
674 auto *builtin_type = llvm::dyn_cast<PDBSymbolTypeBuiltin>(&type);
675 assert(builtin_type)((builtin_type) ? static_cast<void> (0) : __assert_fail
("builtin_type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 675, __PRETTY_FUNCTION__))
;
676 PDB_BuiltinType builtin_kind = builtin_type->getBuiltinType();
677 if (builtin_kind == PDB_BuiltinType::None)
678 return nullptr;
679
680 uint64_t bytes = builtin_type->getLength();
681 Encoding encoding = TranslateBuiltinEncoding(builtin_kind);
682 CompilerType builtin_ast_type = GetBuiltinTypeForPDBEncodingAndBitSize(
683 m_ast, *builtin_type, encoding, bytes * 8);
684
685 if (builtin_type->isConstType())
686 builtin_ast_type = builtin_ast_type.AddConstModifier();
687
688 if (builtin_type->isVolatileType())
689 builtin_ast_type = builtin_ast_type.AddVolatileModifier();
690
691 auto type_name = GetPDBBuiltinTypeName(*builtin_type, builtin_ast_type);
692
693 return std::make_shared<lldb_private::Type>(
694 builtin_type->getSymIndexId(), m_ast.GetSymbolFile(), type_name, bytes,
695 nullptr, LLDB_INVALID_UID(18446744073709551615UL), lldb_private::Type::eEncodingIsUID, decl,
696 builtin_ast_type, lldb_private::Type::eResolveStateFull);
697 } break;
698 case PDB_SymType::PointerType: {
699 auto *pointer_type = llvm::dyn_cast<PDBSymbolTypePointer>(&type);
700 assert(pointer_type)((pointer_type) ? static_cast<void> (0) : __assert_fail
("pointer_type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 700, __PRETTY_FUNCTION__))
;
701 Type *pointee_type = m_ast.GetSymbolFile()->ResolveTypeUID(
702 pointer_type->getPointeeType()->getSymIndexId());
703 if (!pointee_type)
704 return nullptr;
705
706 if (pointer_type->isPointerToDataMember() ||
707 pointer_type->isPointerToMemberFunction()) {
708 auto class_parent_uid = pointer_type->getRawSymbol().getClassParentId();
709 auto class_parent_type =
710 m_ast.GetSymbolFile()->ResolveTypeUID(class_parent_uid);
711 assert(class_parent_type)((class_parent_type) ? static_cast<void> (0) : __assert_fail
("class_parent_type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 711, __PRETTY_FUNCTION__))
;
712
713 CompilerType pointer_ast_type;
714 pointer_ast_type = ClangASTContext::CreateMemberPointerType(
715 class_parent_type->GetLayoutCompilerType(),
716 pointee_type->GetForwardCompilerType());
717 assert(pointer_ast_type)((pointer_ast_type) ? static_cast<void> (0) : __assert_fail
("pointer_ast_type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 717, __PRETTY_FUNCTION__))
;
718
719 return std::make_shared<lldb_private::Type>(
720 pointer_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
721 pointer_type->getLength(), nullptr, LLDB_INVALID_UID(18446744073709551615UL),
722 lldb_private::Type::eEncodingIsUID, decl, pointer_ast_type,
723 lldb_private::Type::eResolveStateForward);
724 }
725
726 CompilerType pointer_ast_type;
727 pointer_ast_type = pointee_type->GetFullCompilerType();
728 if (pointer_type->isReference())
729 pointer_ast_type = pointer_ast_type.GetLValueReferenceType();
730 else if (pointer_type->isRValueReference())
731 pointer_ast_type = pointer_ast_type.GetRValueReferenceType();
732 else
733 pointer_ast_type = pointer_ast_type.GetPointerType();
734
735 if (pointer_type->isConstType())
736 pointer_ast_type = pointer_ast_type.AddConstModifier();
737
738 if (pointer_type->isVolatileType())
739 pointer_ast_type = pointer_ast_type.AddVolatileModifier();
740
741 if (pointer_type->isRestrictedType())
742 pointer_ast_type = pointer_ast_type.AddRestrictModifier();
743
744 return std::make_shared<lldb_private::Type>(
745 pointer_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
746 pointer_type->getLength(), nullptr, LLDB_INVALID_UID(18446744073709551615UL),
747 lldb_private::Type::eEncodingIsUID, decl, pointer_ast_type,
748 lldb_private::Type::eResolveStateFull);
749 } break;
750 default:
751 break;
752 }
753 return nullptr;
754}
755
756bool PDBASTParser::CompleteTypeFromPDB(
757 lldb_private::CompilerType &compiler_type) {
758 if (GetClangASTImporter().CanImport(compiler_type))
759 return GetClangASTImporter().CompleteType(compiler_type);
760
761 // Remove the type from the forward declarations to avoid
762 // an endless recursion for types like a linked list.
763 clang::CXXRecordDecl *record_decl =
764 m_ast.GetAsCXXRecordDecl(compiler_type.GetOpaqueQualType());
765 auto uid_it = m_forward_decl_to_uid.find(record_decl);
766 if (uid_it == m_forward_decl_to_uid.end())
767 return true;
768
769 auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
770 if (!symbol_file)
771 return false;
772
773 std::unique_ptr<PDBSymbol> symbol =
774 symbol_file->GetPDBSession().getSymbolById(uid_it->getSecond());
775 if (!symbol)
776 return false;
777
778 m_forward_decl_to_uid.erase(uid_it);
779
780 ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
781 false);
782
783 switch (symbol->getSymTag()) {
784 case PDB_SymType::UDT: {
785 auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(symbol.get());
786 if (!udt)
787 return false;
788
789 return CompleteTypeFromUDT(*symbol_file, compiler_type, *udt);
790 }
791 default:
792 llvm_unreachable("not a forward clang type decl!")::llvm::llvm_unreachable_internal("not a forward clang type decl!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 792)
;
793 }
794}
795
796clang::Decl *
797PDBASTParser::GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) {
798 auto it = m_uid_to_decl.find(symbol.getSymIndexId());
799 if (it != m_uid_to_decl.end())
800 return it->second;
801
802 auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
803 if (!symbol_file)
804 return nullptr;
805
806 // First of all, check if the symbol is a member of a class. Resolve the full
807 // class type and return the declaration from the cache if so.
808 auto tag = symbol.getSymTag();
809 if (tag == PDB_SymType::Data || tag == PDB_SymType::Function) {
810 const IPDBSession &session = symbol.getSession();
811 const IPDBRawSymbol &raw = symbol.getRawSymbol();
812
813 auto class_parent_id = raw.getClassParentId();
814 if (session.getSymbolById(class_parent_id)) {
815 auto class_parent_type = symbol_file->ResolveTypeUID(class_parent_id);
816 if (!class_parent_type)
817 return nullptr;
818
819 class_parent_type->GetFullCompilerType();
820
821 return m_uid_to_decl.lookup(symbol.getSymIndexId());
822 }
823 }
824
825 // If we are here, then the symbol is not belonging to a class and is not
826 // contained in the cache. So create a declaration for it.
827 switch (symbol.getSymTag()) {
828 case PDB_SymType::Data: {
829 auto data = llvm::dyn_cast<PDBSymbolData>(&symbol);
830 assert(data)((data) ? static_cast<void> (0) : __assert_fail ("data"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 830, __PRETTY_FUNCTION__))
;
831
832 auto decl_context = GetDeclContextContainingSymbol(symbol);
833 assert(decl_context)((decl_context) ? static_cast<void> (0) : __assert_fail
("decl_context", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 833, __PRETTY_FUNCTION__))
;
834
835 // May be the current context is a class really, but we haven't found
836 // any class parent. This happens e.g. in the case of class static
837 // variables - they has two symbols, one is a child of the class when
838 // another is a child of the exe. So always complete the parent and use
839 // an existing declaration if possible.
840 if (auto parent_decl = llvm::dyn_cast_or_null<clang::TagDecl>(decl_context))
841 m_ast.GetCompleteDecl(parent_decl);
842
843 auto name = PDBNameDropScope(data->getName());
844
845 // Check if the current context already contains the symbol with the name.
846 clang::Decl *decl =
847 GetDeclFromContextByName(*m_ast.getASTContext(), *decl_context, name);
848 if (!decl) {
849 auto type = symbol_file->ResolveTypeUID(data->getTypeId());
850 if (!type)
851 return nullptr;
852
853 decl = m_ast.CreateVariableDeclaration(
854 decl_context, name.c_str(),
855 ClangUtil::GetQualType(type->GetLayoutCompilerType()));
856 }
857
858 m_uid_to_decl[data->getSymIndexId()] = decl;
859
860 return decl;
861 }
862 case PDB_SymType::Function: {
863 auto func = llvm::dyn_cast<PDBSymbolFunc>(&symbol);
864 assert(func)((func) ? static_cast<void> (0) : __assert_fail ("func"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 864, __PRETTY_FUNCTION__))
;
865
866 auto decl_context = GetDeclContextContainingSymbol(symbol);
867 assert(decl_context)((decl_context) ? static_cast<void> (0) : __assert_fail
("decl_context", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 867, __PRETTY_FUNCTION__))
;
868
869 auto name = PDBNameDropScope(func->getName());
870
871 auto type = symbol_file->ResolveTypeUID(func->getSymIndexId());
872 if (!type)
873 return nullptr;
874
875 auto storage = func->isStatic() ? clang::StorageClass::SC_Static
876 : clang::StorageClass::SC_None;
877
878 auto decl = m_ast.CreateFunctionDeclaration(
879 decl_context, name.c_str(), type->GetForwardCompilerType(), storage,
880 func->hasInlineAttribute());
881
882 m_uid_to_decl[func->getSymIndexId()] = decl;
883
884 return decl;
885 }
886 default: {
887 // It's not a variable and not a function, check if it's a type
888 auto type = symbol_file->ResolveTypeUID(symbol.getSymIndexId());
889 if (!type)
890 return nullptr;
891
892 return m_uid_to_decl.lookup(symbol.getSymIndexId());
893 }
894 }
895}
896
897clang::DeclContext *
898PDBASTParser::GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) {
899 if (symbol.getSymTag() == PDB_SymType::Function) {
900 clang::DeclContext *result =
901 llvm::dyn_cast_or_null<clang::FunctionDecl>(GetDeclForSymbol(symbol));
902
903 if (result)
904 m_decl_context_to_uid[result] = symbol.getSymIndexId();
905
906 return result;
907 }
908
909 auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
910 if (!symbol_file)
911 return nullptr;
912
913 auto type = symbol_file->ResolveTypeUID(symbol.getSymIndexId());
914 if (!type)
915 return nullptr;
916
917 clang::DeclContext *result =
918 m_ast.GetDeclContextForType(type->GetForwardCompilerType());
919
920 if (result)
921 m_decl_context_to_uid[result] = symbol.getSymIndexId();
922
923 return result;
924}
925
926clang::DeclContext *PDBASTParser::GetDeclContextContainingSymbol(
927 const llvm::pdb::PDBSymbol &symbol) {
928 auto parent = GetClassOrFunctionParent(symbol);
929 while (parent) {
930 if (auto parent_context = GetDeclContextForSymbol(*parent))
931 return parent_context;
932
933 parent = GetClassOrFunctionParent(*parent);
934 }
935
936 // We can't find any class or function parent of the symbol. So analyze
937 // the full symbol name. The symbol may be belonging to a namespace
938 // or function (or even to a class if it's e.g. a static variable symbol).
939 // We do not use CPlusPlusNameParser because it fails on things like
940 // `anonymous namespace'.
941
942 // TODO: Make clang to emit full names for variables in namespaces
943 // (as MSVC does)
944
945 auto context = symbol.getRawSymbol().getName();
946 auto context_size = context.rfind("::");
947 if (context_size == std::string::npos)
948 context_size = 0;
949 context = context.substr(0, context_size);
950
951 // Check if there is a symbol with the name of the context.
952
953 auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
954 if (!symbol_file)
955 return m_ast.GetTranslationUnitDecl();
956
957 auto global = symbol_file->GetPDBSession().getGlobalScope();
958 if (!global)
959 return m_ast.GetTranslationUnitDecl();
960
961 TypeMap types;
962 if (auto children_enum =
963 global->findChildren(PDB_SymType::None, context, NS_CaseSensitive))
964 while (auto child = children_enum->getNext())
965 if (auto child_context = GetDeclContextForSymbol(*child))
966 return child_context;
967
968 // Split context and retrieve nested namespaces
969 auto curr_context = m_ast.GetTranslationUnitDecl();
970 std::string::size_type from = 0;
971 while (from < context_size) {
972 auto to = context.find("::", from);
973 if (to == std::string::npos)
974 to = context_size;
975
976 auto namespace_name = context.substr(from, to - from);
977 auto namespace_name_c_str = IsAnonymousNamespaceName(namespace_name)
978 ? nullptr
979 : namespace_name.c_str();
980 auto namespace_decl =
981 m_ast.GetUniqueNamespaceDeclaration(namespace_name_c_str, curr_context);
982
983 m_parent_to_namespaces[curr_context].insert(namespace_decl);
984
985 curr_context = namespace_decl;
986 from = to + 2;
987 }
988
989 return curr_context;
990}
991
992void PDBASTParser::ParseDeclsForDeclContext(
993 const clang::DeclContext *decl_context) {
994 auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
995 if (!symbol_file)
996 return;
997
998 IPDBSession &session = symbol_file->GetPDBSession();
999 auto symbol_up =
1000 session.getSymbolById(m_decl_context_to_uid.lookup(decl_context));
1001 auto global_up = session.getGlobalScope();
1002
1003 PDBSymbol *symbol;
1004 if (symbol_up)
1005 symbol = symbol_up.get();
1006 else if (global_up)
1007 symbol = global_up.get();
1008 else
1009 return;
1010
1011 if (auto children = symbol->findAllChildren())
1012 while (auto child = children->getNext())
1013 GetDeclForSymbol(*child);
1014}
1015
1016clang::NamespaceDecl *
1017PDBASTParser::FindNamespaceDecl(const clang::DeclContext *parent,
1018 llvm::StringRef name) {
1019 if (!parent)
1020 parent = m_ast.GetTranslationUnitDecl();
1021
1022 auto it = m_parent_to_namespaces.find(parent);
1023 if (it == m_parent_to_namespaces.end())
1024 return nullptr;
1025
1026 for (auto namespace_decl : it->second)
1027 if (namespace_decl->getName().equals(name))
1028 return namespace_decl;
1029
1030 for (auto namespace_decl : it->second)
1031 if (namespace_decl->isAnonymousNamespace())
1032 return FindNamespaceDecl(namespace_decl, name);
1033
1034 return nullptr;
1035}
1036
1037std::string PDBASTParser::PDBNameDropScope(const std::string &name) {
1038 // Not all PDB names can be parsed with CPlusPlusNameParser.
1039 // E.g. it fails on names containing `anonymous namespace'.
1040 // So we simply drop everything before '::'
1041
1042 auto offset = name.rfind("::");
1043 if (offset == std::string::npos)
1044 return name;
1045 assert(offset + 2 <= name.size())((offset + 2 <= name.size()) ? static_cast<void> (0)
: __assert_fail ("offset + 2 <= name.size()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 1045, __PRETTY_FUNCTION__))
;
1046
1047 return name.substr(offset + 2);
1048}
1049
1050bool PDBASTParser::AddEnumValue(CompilerType enum_type,
1051 const PDBSymbolData &enum_value) {
1052 Declaration decl;
1053 Variant v = enum_value.getValue();
1054 std::string name = PDBNameDropScope(enum_value.getName());
1055 int64_t raw_value;
1056 switch (v.Type) {
1057 case PDB_VariantType::Int8:
1058 raw_value = v.Value.Int8;
1059 break;
1060 case PDB_VariantType::Int16:
1061 raw_value = v.Value.Int16;
1062 break;
1063 case PDB_VariantType::Int32:
1064 raw_value = v.Value.Int32;
1065 break;
1066 case PDB_VariantType::Int64:
1067 raw_value = v.Value.Int64;
1068 break;
1069 case PDB_VariantType::UInt8:
1070 raw_value = v.Value.UInt8;
1071 break;
1072 case PDB_VariantType::UInt16:
1073 raw_value = v.Value.UInt16;
1074 break;
1075 case PDB_VariantType::UInt32:
1076 raw_value = v.Value.UInt32;
1077 break;
1078 case PDB_VariantType::UInt64:
1079 raw_value = v.Value.UInt64;
1080 break;
1081 default:
1082 return false;
1083 }
1084 CompilerType underlying_type =
1085 m_ast.GetEnumerationIntegerType(enum_type.GetOpaqueQualType());
1086 uint32_t byte_size = m_ast.getASTContext()->getTypeSize(
1087 ClangUtil::GetQualType(underlying_type));
1088 auto enum_constant_decl = m_ast.AddEnumerationValueToEnumerationType(
1089 enum_type.GetOpaqueQualType(), underlying_type, decl, name.c_str(),
1090 raw_value, byte_size * 8);
1091 if (!enum_constant_decl)
1092 return false;
1093
1094 m_uid_to_decl[enum_value.getSymIndexId()] = enum_constant_decl;
1095
1096 return true;
1097}
1098
1099bool PDBASTParser::CompleteTypeFromUDT(
1100 lldb_private::SymbolFile &symbol_file,
1101 lldb_private::CompilerType &compiler_type,
1102 llvm::pdb::PDBSymbolTypeUDT &udt) {
1103 ClangASTImporter::LayoutInfo layout_info;
1104 layout_info.bit_size = udt.getLength() * 8;
1105
1106 auto nested_enums = udt.findAllChildren<PDBSymbolTypeUDT>();
1107 if (nested_enums)
1108 while (auto nested = nested_enums->getNext())
1109 symbol_file.ResolveTypeUID(nested->getSymIndexId());
1110
1111 auto bases_enum = udt.findAllChildren<PDBSymbolTypeBaseClass>();
1112 if (bases_enum)
1113 AddRecordBases(symbol_file, compiler_type,
1114 TranslateUdtKind(udt.getUdtKind()), *bases_enum,
1115 layout_info);
1116
1117 auto members_enum = udt.findAllChildren<PDBSymbolData>();
1118 if (members_enum)
1119 AddRecordMembers(symbol_file, compiler_type, *members_enum, layout_info);
1120
1121 auto methods_enum = udt.findAllChildren<PDBSymbolFunc>();
1122 if (methods_enum)
1123 AddRecordMethods(symbol_file, compiler_type, *methods_enum);
1124
1125 m_ast.AddMethodOverridesForCXXRecordType(compiler_type.GetOpaqueQualType());
1126 ClangASTContext::BuildIndirectFields(compiler_type);
1127 ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
1128
1129 clang::CXXRecordDecl *record_decl =
1130 m_ast.GetAsCXXRecordDecl(compiler_type.GetOpaqueQualType());
1131 if (!record_decl)
1132 return static_cast<bool>(compiler_type);
1133
1134 GetClangASTImporter().InsertRecordDecl(record_decl, layout_info);
1135
1136 return static_cast<bool>(compiler_type);
1137}
1138
1139void PDBASTParser::AddRecordMembers(
1140 lldb_private::SymbolFile &symbol_file,
1141 lldb_private::CompilerType &record_type,
1142 PDBDataSymbolEnumerator &members_enum,
1143 lldb_private::ClangASTImporter::LayoutInfo &layout_info) {
1144 while (auto member = members_enum.getNext()) {
1145 if (member->isCompilerGenerated())
1146 continue;
1147
1148 auto member_name = member->getName();
1149
1150 auto member_type = symbol_file.ResolveTypeUID(member->getTypeId());
1151 if (!member_type)
1152 continue;
1153
1154 auto member_comp_type = member_type->GetLayoutCompilerType();
1155 if (!member_comp_type.GetCompleteType()) {
1156 symbol_file.GetObjectFile()->GetModule()->ReportError(
1157 ":: Class '%s' has a member '%s' of type '%s' "
1158 "which does not have a complete definition.",
1159 record_type.GetTypeName().GetCString(), member_name.c_str(),
1160 member_comp_type.GetTypeName().GetCString());
1161 if (ClangASTContext::StartTagDeclarationDefinition(member_comp_type))
1162 ClangASTContext::CompleteTagDeclarationDefinition(member_comp_type);
1163 }
1164
1165 auto access = TranslateMemberAccess(member->getAccess());
1166
1167 switch (member->getDataKind()) {
1168 case PDB_DataKind::Member: {
1169 auto location_type = member->getLocationType();
1170
1171 auto bit_size = member->getLength();
1172 if (location_type == PDB_LocType::ThisRel)
1173 bit_size *= 8;
1174
1175 auto decl = ClangASTContext::AddFieldToRecordType(
1176 record_type, member_name.c_str(), member_comp_type, access, bit_size);
1177 if (!decl)
1178 continue;
1179
1180 m_uid_to_decl[member->getSymIndexId()] = decl;
1181
1182 auto offset = member->getOffset() * 8;
1183 if (location_type == PDB_LocType::BitField)
1184 offset += member->getBitPosition();
1185
1186 layout_info.field_offsets.insert(std::make_pair(decl, offset));
1187
1188 break;
1189 }
1190 case PDB_DataKind::StaticMember: {
1191 auto decl = ClangASTContext::AddVariableToRecordType(
1192 record_type, member_name.c_str(), member_comp_type, access);
1193 if (!decl)
1194 continue;
1195
1196 m_uid_to_decl[member->getSymIndexId()] = decl;
1197
1198 break;
1199 }
1200 default:
1201 llvm_unreachable("unsupported PDB data kind")::llvm::llvm_unreachable_internal("unsupported PDB data kind"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 1201)
;
1202 }
1203 }
1204}
1205
1206void PDBASTParser::AddRecordBases(
1207 lldb_private::SymbolFile &symbol_file,
1208 lldb_private::CompilerType &record_type, int record_kind,
1209 PDBBaseClassSymbolEnumerator &bases_enum,
1210 lldb_private::ClangASTImporter::LayoutInfo &layout_info) const {
1211 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> base_classes;
1212
1213 while (auto base = bases_enum.getNext()) {
1214 auto base_type = symbol_file.ResolveTypeUID(base->getTypeId());
1215 if (!base_type)
1216 continue;
1217
1218 auto base_comp_type = base_type->GetFullCompilerType();
1219 if (!base_comp_type.GetCompleteType()) {
1220 symbol_file.GetObjectFile()->GetModule()->ReportError(
1221 ":: Class '%s' has a base class '%s' "
1222 "which does not have a complete definition.",
1223 record_type.GetTypeName().GetCString(),
1224 base_comp_type.GetTypeName().GetCString());
1225 if (ClangASTContext::StartTagDeclarationDefinition(base_comp_type))
1226 ClangASTContext::CompleteTagDeclarationDefinition(base_comp_type);
1227 }
1228
1229 auto access = TranslateMemberAccess(base->getAccess());
1230
1231 auto is_virtual = base->isVirtualBaseClass();
1232
1233 std::unique_ptr<clang::CXXBaseSpecifier> base_spec =
1234 m_ast.CreateBaseClassSpecifier(base_comp_type.GetOpaqueQualType(),
1235 access, is_virtual,
1236 record_kind == clang::TTK_Class);
1237 lldbassert(base_spec)lldb_private::lldb_assert(static_cast<bool>(base_spec),
"base_spec", __FUNCTION__, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp"
, 1237)
;
1238
1239 base_classes.push_back(std::move(base_spec));
1240
1241 if (is_virtual)
1242 continue;
1243
1244 auto decl = m_ast.GetAsCXXRecordDecl(base_comp_type.GetOpaqueQualType());
1245 if (!decl)
1246 continue;
1247
1248 auto offset = clang::CharUnits::fromQuantity(base->getOffset());
1249 layout_info.base_offsets.insert(std::make_pair(decl, offset));
1250 }
1251
1252 m_ast.TransferBaseClasses(record_type.GetOpaqueQualType(),
1253 std::move(base_classes));
1254}
1255
1256void PDBASTParser::AddRecordMethods(lldb_private::SymbolFile &symbol_file,
1257 lldb_private::CompilerType &record_type,
1258 PDBFuncSymbolEnumerator &methods_enum) {
1259 while (auto method = methods_enum.getNext()) {
1260 auto name = PDBNameDropScope(method->getName().c_str());
1261
1262 auto method_type = symbol_file.ResolveTypeUID(method->getSymIndexId());
1263 // MSVC specific __vecDelDtor.
1264 if (!method_type)
1265 continue;
1266
1267 auto method_comp_type = method_type->GetFullCompilerType();
1268 if (!method_comp_type.GetCompleteType()) {
1269 symbol_file.GetObjectFile()->GetModule()->ReportError(
1270 ":: Class '%s' has a method '%s' whose type cannot be completed.",
1271 record_type.GetTypeName().GetCString(),
1272 method_comp_type.GetTypeName().GetCString());
1273 if (ClangASTContext::StartTagDeclarationDefinition(method_comp_type))
1274 ClangASTContext::CompleteTagDeclarationDefinition(method_comp_type);
1275 }
1276
1277 // TODO: get mangled name for the method.
1278 auto decl = m_ast.AddMethodToCXXRecordType(
1279 record_type.GetOpaqueQualType(), name.c_str(),
1280 /*mangled_name*/ nullptr, method_comp_type,
1281 TranslateMemberAccess(method->getAccess()), method->isVirtual(),
1282 method->isStatic(), method->hasInlineAttribute(),
1283 /*is_explicit*/ false, // FIXME: Need this field in CodeView.
1284 /*is_attr_used*/ false,
1285 /*is_artificial*/ method->isCompilerGenerated());
1286 if (!decl)
1287 continue;
1288
1289 m_uid_to_decl[method->getSymIndexId()] = decl;
1290 }
1291}

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

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