Bug Summary

File:src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
Warning:line 1794, column 11
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name TypeSystemClang.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 -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/clang/include -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

1//===-- TypeSystemClang.cpp -----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "TypeSystemClang.h"
10
11#include "llvm/Support/FormatAdapters.h"
12#include "llvm/Support/FormatVariadic.h"
13
14#include <mutex>
15#include <string>
16#include <vector>
17
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/ASTImporter.h"
20#include "clang/AST/Attr.h"
21#include "clang/AST/CXXInheritance.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/DeclTemplate.h"
24#include "clang/AST/Mangle.h"
25#include "clang/AST/RecordLayout.h"
26#include "clang/AST/Type.h"
27#include "clang/AST/VTableBuilder.h"
28#include "clang/Basic/Builtins.h"
29#include "clang/Basic/Diagnostic.h"
30#include "clang/Basic/FileManager.h"
31#include "clang/Basic/FileSystemOptions.h"
32#include "clang/Basic/LangStandard.h"
33#include "clang/Basic/SourceManager.h"
34#include "clang/Basic/TargetInfo.h"
35#include "clang/Basic/TargetOptions.h"
36#include "clang/Frontend/FrontendOptions.h"
37#include "clang/Lex/HeaderSearch.h"
38#include "clang/Lex/HeaderSearchOptions.h"
39#include "clang/Lex/ModuleMap.h"
40#include "clang/Sema/Sema.h"
41
42#include "llvm/Support/Signals.h"
43#include "llvm/Support/Threading.h"
44
45#include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
46#include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
47#include "Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h"
48#include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
49#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
50#include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
51#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
52#include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
53#include "lldb/Utility/ArchSpec.h"
54#include "lldb/Utility/Flags.h"
55
56#include "lldb/Core/DumpDataExtractor.h"
57#include "lldb/Core/Module.h"
58#include "lldb/Core/PluginManager.h"
59#include "lldb/Core/StreamFile.h"
60#include "lldb/Core/ThreadSafeDenseMap.h"
61#include "lldb/Core/UniqueCStringMap.h"
62#include "lldb/Symbol/ObjectFile.h"
63#include "lldb/Symbol/SymbolFile.h"
64#include "lldb/Target/ExecutionContext.h"
65#include "lldb/Target/Language.h"
66#include "lldb/Target/Process.h"
67#include "lldb/Target/Target.h"
68#include "lldb/Utility/DataExtractor.h"
69#include "lldb/Utility/LLDBAssert.h"
70#include "lldb/Utility/Log.h"
71#include "lldb/Utility/RegularExpression.h"
72#include "lldb/Utility/Scalar.h"
73
74#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
75#include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
76#include "Plugins/SymbolFile/PDB/PDBASTParser.h"
77
78#include <cstdio>
79
80#include <mutex>
81
82using namespace lldb;
83using namespace lldb_private;
84using namespace clang;
85using llvm::StringSwitch;
86
87LLDB_PLUGIN_DEFINE(TypeSystemClang)namespace lldb_private { void lldb_initialize_TypeSystemClang
() { TypeSystemClang::Initialize(); } void lldb_terminate_TypeSystemClang
() { TypeSystemClang::Terminate(); } }
88
89namespace {
90static void VerifyDecl(clang::Decl *decl) {
91 assert(decl && "VerifyDecl called with nullptr?")((void)0);
92#ifndef NDEBUG1
93 // We don't care about the actual access value here but only want to trigger
94 // that Clang calls its internal Decl::AccessDeclContextSanity check.
95 decl->getAccess();
96#endif
97}
98
99static inline bool
100TypeSystemClangSupportsLanguage(lldb::LanguageType language) {
101 return language == eLanguageTypeUnknown || // Clang is the default type system
102 lldb_private::Language::LanguageIsC(language) ||
103 lldb_private::Language::LanguageIsCPlusPlus(language) ||
104 lldb_private::Language::LanguageIsObjC(language) ||
105 lldb_private::Language::LanguageIsPascal(language) ||
106 // Use Clang for Rust until there is a proper language plugin for it
107 language == eLanguageTypeRust ||
108 language == eLanguageTypeExtRenderScript ||
109 // Use Clang for D until there is a proper language plugin for it
110 language == eLanguageTypeD ||
111 // Open Dylan compiler debug info is designed to be Clang-compatible
112 language == eLanguageTypeDylan;
113}
114
115// Checks whether m1 is an overload of m2 (as opposed to an override). This is
116// called by addOverridesForMethod to distinguish overrides (which share a
117// vtable entry) from overloads (which require distinct entries).
118bool isOverload(clang::CXXMethodDecl *m1, clang::CXXMethodDecl *m2) {
119 // FIXME: This should detect covariant return types, but currently doesn't.
120 lldbassert(&m1->getASTContext() == &m2->getASTContext() &&lldb_private::lldb_assert(static_cast<bool>(&m1->
getASTContext() == &m2->getASTContext() && "Methods should have the same AST context"
), "&m1->getASTContext() == &m2->getASTContext() && \"Methods should have the same AST context\""
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, 121)
121 "Methods should have the same AST context")lldb_private::lldb_assert(static_cast<bool>(&m1->
getASTContext() == &m2->getASTContext() && "Methods should have the same AST context"
), "&m1->getASTContext() == &m2->getASTContext() && \"Methods should have the same AST context\""
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, 121)
;
122 clang::ASTContext &context = m1->getASTContext();
123
124 const auto *m1Type = llvm::cast<clang::FunctionProtoType>(
125 context.getCanonicalType(m1->getType()));
126
127 const auto *m2Type = llvm::cast<clang::FunctionProtoType>(
128 context.getCanonicalType(m2->getType()));
129
130 auto compareArgTypes = [&context](const clang::QualType &m1p,
131 const clang::QualType &m2p) {
132 return context.hasSameType(m1p.getUnqualifiedType(),
133 m2p.getUnqualifiedType());
134 };
135
136 // FIXME: In C++14 and later, we can just pass m2Type->param_type_end()
137 // as a fourth parameter to std::equal().
138 return (m1->getNumParams() != m2->getNumParams()) ||
139 !std::equal(m1Type->param_type_begin(), m1Type->param_type_end(),
140 m2Type->param_type_begin(), compareArgTypes);
141}
142
143// If decl is a virtual method, walk the base classes looking for methods that
144// decl overrides. This table of overridden methods is used by IRGen to
145// determine the vtable layout for decl's parent class.
146void addOverridesForMethod(clang::CXXMethodDecl *decl) {
147 if (!decl->isVirtual())
148 return;
149
150 clang::CXXBasePaths paths;
151 llvm::SmallVector<clang::NamedDecl *, 4> decls;
152
153 auto find_overridden_methods =
154 [&decls, decl](const clang::CXXBaseSpecifier *specifier,
155 clang::CXXBasePath &path) {
156 if (auto *base_record = llvm::dyn_cast<clang::CXXRecordDecl>(
157 specifier->getType()->getAs<clang::RecordType>()->getDecl())) {
158
159 clang::DeclarationName name = decl->getDeclName();
160
161 // If this is a destructor, check whether the base class destructor is
162 // virtual.
163 if (name.getNameKind() == clang::DeclarationName::CXXDestructorName)
164 if (auto *baseDtorDecl = base_record->getDestructor()) {
165 if (baseDtorDecl->isVirtual()) {
166 decls.push_back(baseDtorDecl);
167 return true;
168 } else
169 return false;
170 }
171
172 // Otherwise, search for name in the base class.
173 for (path.Decls = base_record->lookup(name).begin();
174 path.Decls != path.Decls.end(); ++path.Decls) {
175 if (auto *method_decl =
176 llvm::dyn_cast<clang::CXXMethodDecl>(*path.Decls))
177 if (method_decl->isVirtual() && !isOverload(decl, method_decl)) {
178 decls.push_back(method_decl);
179 return true;
180 }
181 }
182 }
183
184 return false;
185 };
186
187 if (decl->getParent()->lookupInBases(find_overridden_methods, paths)) {
188 for (auto *overridden_decl : decls)
189 decl->addOverriddenMethod(
190 llvm::cast<clang::CXXMethodDecl>(overridden_decl));
191 }
192}
193}
194
195static lldb::addr_t GetVTableAddress(Process &process,
196 VTableContextBase &vtable_ctx,
197 ValueObject &valobj,
198 const ASTRecordLayout &record_layout) {
199 // Retrieve type info
200 CompilerType pointee_type;
201 CompilerType this_type(valobj.GetCompilerType());
202 uint32_t type_info = this_type.GetTypeInfo(&pointee_type);
203 if (!type_info)
204 return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
205
206 // Check if it's a pointer or reference
207 bool ptr_or_ref = false;
208 if (type_info & (eTypeIsPointer | eTypeIsReference)) {
209 ptr_or_ref = true;
210 type_info = pointee_type.GetTypeInfo();
211 }
212
213 // We process only C++ classes
214 const uint32_t cpp_class = eTypeIsClass | eTypeIsCPlusPlus;
215 if ((type_info & cpp_class) != cpp_class)
216 return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
217
218 // Calculate offset to VTable pointer
219 lldb::offset_t vbtable_ptr_offset =
220 vtable_ctx.isMicrosoft() ? record_layout.getVBPtrOffset().getQuantity()
221 : 0;
222
223 if (ptr_or_ref) {
224 // We have a pointer / ref to object, so read
225 // VTable pointer from process memory
226
227 if (valobj.GetAddressTypeOfChildren() != eAddressTypeLoad)
228 return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
229
230 auto vbtable_ptr_addr = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
231 if (vbtable_ptr_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
232 return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
233
234 vbtable_ptr_addr += vbtable_ptr_offset;
235
236 Status err;
237 return process.ReadPointerFromMemory(vbtable_ptr_addr, err);
238 }
239
240 // We have an object already read from process memory,
241 // so just extract VTable pointer from it
242
243 DataExtractor data;
244 Status err;
245 auto size = valobj.GetData(data, err);
246 if (err.Fail() || vbtable_ptr_offset + data.GetAddressByteSize() > size)
247 return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
248
249 return data.GetAddress(&vbtable_ptr_offset);
250}
251
252static int64_t ReadVBaseOffsetFromVTable(Process &process,
253 VTableContextBase &vtable_ctx,
254 lldb::addr_t vtable_ptr,
255 const CXXRecordDecl *cxx_record_decl,
256 const CXXRecordDecl *base_class_decl) {
257 if (vtable_ctx.isMicrosoft()) {
258 clang::MicrosoftVTableContext &msoft_vtable_ctx =
259 static_cast<clang::MicrosoftVTableContext &>(vtable_ctx);
260
261 // Get the index into the virtual base table. The
262 // index is the index in uint32_t from vbtable_ptr
263 const unsigned vbtable_index =
264 msoft_vtable_ctx.getVBTableIndex(cxx_record_decl, base_class_decl);
265 const lldb::addr_t base_offset_addr = vtable_ptr + vbtable_index * 4;
266 Status err;
267 return process.ReadSignedIntegerFromMemory(base_offset_addr, 4, INT64_MAX0x7fffffffffffffffLL,
268 err);
269 }
270
271 clang::ItaniumVTableContext &itanium_vtable_ctx =
272 static_cast<clang::ItaniumVTableContext &>(vtable_ctx);
273
274 clang::CharUnits base_offset_offset =
275 itanium_vtable_ctx.getVirtualBaseOffsetOffset(cxx_record_decl,
276 base_class_decl);
277 const lldb::addr_t base_offset_addr =
278 vtable_ptr + base_offset_offset.getQuantity();
279 const uint32_t base_offset_size = process.GetAddressByteSize();
280 Status err;
281 return process.ReadSignedIntegerFromMemory(base_offset_addr, base_offset_size,
282 INT64_MAX0x7fffffffffffffffLL, err);
283}
284
285static bool GetVBaseBitOffset(VTableContextBase &vtable_ctx,
286 ValueObject &valobj,
287 const ASTRecordLayout &record_layout,
288 const CXXRecordDecl *cxx_record_decl,
289 const CXXRecordDecl *base_class_decl,
290 int32_t &bit_offset) {
291 ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
292 Process *process = exe_ctx.GetProcessPtr();
293 if (!process)
294 return false;
295
296 lldb::addr_t vtable_ptr =
297 GetVTableAddress(*process, vtable_ctx, valobj, record_layout);
298 if (vtable_ptr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
299 return false;
300
301 auto base_offset = ReadVBaseOffsetFromVTable(
302 *process, vtable_ctx, vtable_ptr, cxx_record_decl, base_class_decl);
303 if (base_offset == INT64_MAX0x7fffffffffffffffLL)
304 return false;
305
306 bit_offset = base_offset * 8;
307
308 return true;
309}
310
311typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, TypeSystemClang *>
312 ClangASTMap;
313
314static ClangASTMap &GetASTMap() {
315 static ClangASTMap *g_map_ptr = nullptr;
316 static llvm::once_flag g_once_flag;
317 llvm::call_once(g_once_flag, []() {
318 g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins
319 });
320 return *g_map_ptr;
321}
322
323TypePayloadClang::TypePayloadClang(OptionalClangModuleID owning_module,
324 bool is_complete_objc_class)
325 : m_payload(owning_module.GetValue()) {
326 SetIsCompleteObjCClass(is_complete_objc_class);
327}
328
329void TypePayloadClang::SetOwningModule(OptionalClangModuleID id) {
330 assert(id.GetValue() < ObjCClassBit)((void)0);
331 bool is_complete = IsCompleteObjCClass();
332 m_payload = id.GetValue();
333 SetIsCompleteObjCClass(is_complete);
334}
335
336static void SetMemberOwningModule(clang::Decl *member,
337 const clang::Decl *parent) {
338 if (!member || !parent)
339 return;
340
341 OptionalClangModuleID id(parent->getOwningModuleID());
342 if (!id.HasValue())
343 return;
344
345 member->setFromASTFile();
346 member->setOwningModuleID(id.GetValue());
347 member->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
348 if (llvm::isa<clang::NamedDecl>(member))
349 if (auto *dc = llvm::dyn_cast<clang::DeclContext>(parent)) {
350 dc->setHasExternalVisibleStorage(true);
351 // This triggers ExternalASTSource::FindExternalVisibleDeclsByName() to be
352 // called when searching for members.
353 dc->setHasExternalLexicalStorage(true);
354 }
355}
356
357char TypeSystemClang::ID;
358
359bool TypeSystemClang::IsOperator(llvm::StringRef name,
360 clang::OverloadedOperatorKind &op_kind) {
361 // All operators have to start with "operator".
362 if (!name.consume_front("operator"))
363 return false;
364
365 // Remember if there was a space after "operator". This is necessary to
366 // check for collisions with strangely named functions like "operatorint()".
367 bool space_after_operator = name.consume_front(" ");
368
369 op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
370 .Case("+", clang::OO_Plus)
371 .Case("+=", clang::OO_PlusEqual)
372 .Case("++", clang::OO_PlusPlus)
373 .Case("-", clang::OO_Minus)
374 .Case("-=", clang::OO_MinusEqual)
375 .Case("--", clang::OO_MinusMinus)
376 .Case("->", clang::OO_Arrow)
377 .Case("->*", clang::OO_ArrowStar)
378 .Case("*", clang::OO_Star)
379 .Case("*=", clang::OO_StarEqual)
380 .Case("/", clang::OO_Slash)
381 .Case("/=", clang::OO_SlashEqual)
382 .Case("%", clang::OO_Percent)
383 .Case("%=", clang::OO_PercentEqual)
384 .Case("^", clang::OO_Caret)
385 .Case("^=", clang::OO_CaretEqual)
386 .Case("&", clang::OO_Amp)
387 .Case("&=", clang::OO_AmpEqual)
388 .Case("&&", clang::OO_AmpAmp)
389 .Case("|", clang::OO_Pipe)
390 .Case("|=", clang::OO_PipeEqual)
391 .Case("||", clang::OO_PipePipe)
392 .Case("~", clang::OO_Tilde)
393 .Case("!", clang::OO_Exclaim)
394 .Case("!=", clang::OO_ExclaimEqual)
395 .Case("=", clang::OO_Equal)
396 .Case("==", clang::OO_EqualEqual)
397 .Case("<", clang::OO_Less)
398 .Case("<<", clang::OO_LessLess)
399 .Case("<<=", clang::OO_LessLessEqual)
400 .Case("<=", clang::OO_LessEqual)
401 .Case(">", clang::OO_Greater)
402 .Case(">>", clang::OO_GreaterGreater)
403 .Case(">>=", clang::OO_GreaterGreaterEqual)
404 .Case(">=", clang::OO_GreaterEqual)
405 .Case("()", clang::OO_Call)
406 .Case("[]", clang::OO_Subscript)
407 .Case(",", clang::OO_Comma)
408 .Default(clang::NUM_OVERLOADED_OPERATORS);
409
410 // We found a fitting operator, so we can exit now.
411 if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
412 return true;
413
414 // After the "operator " or "operator" part is something unknown. This means
415 // it's either one of the named operators (new/delete), a conversion operator
416 // (e.g. operator bool) or a function which name starts with "operator"
417 // (e.g. void operatorbool).
418
419 // If it's a function that starts with operator it can't have a space after
420 // "operator" because identifiers can't contain spaces.
421 // E.g. "operator int" (conversion operator)
422 // vs. "operatorint" (function with colliding name).
423 if (!space_after_operator)
424 return false; // not an operator.
425
426 // Now the operator is either one of the named operators or a conversion
427 // operator.
428 op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
429 .Case("new", clang::OO_New)
430 .Case("new[]", clang::OO_Array_New)
431 .Case("delete", clang::OO_Delete)
432 .Case("delete[]", clang::OO_Array_Delete)
433 // conversion operators hit this case.
434 .Default(clang::NUM_OVERLOADED_OPERATORS);
435
436 return true;
437}
438
439clang::AccessSpecifier
440TypeSystemClang::ConvertAccessTypeToAccessSpecifier(AccessType access) {
441 switch (access) {
442 default:
443 break;
444 case eAccessNone:
445 return AS_none;
446 case eAccessPublic:
447 return AS_public;
448 case eAccessPrivate:
449 return AS_private;
450 case eAccessProtected:
451 return AS_protected;
452 }
453 return AS_none;
454}
455
456static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
457 // FIXME: Cleanup per-file based stuff.
458
459 // Set some properties which depend solely on the input kind; it would be
460 // nice to move these to the language standard, and have the driver resolve
461 // the input kind + language standard.
462 if (IK.getLanguage() == clang::Language::Asm) {
463 Opts.AsmPreprocessor = 1;
464 } else if (IK.isObjectiveC()) {
465 Opts.ObjC = 1;
466 }
467
468 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
469
470 if (LangStd == LangStandard::lang_unspecified) {
471 // Based on the base language, pick one.
472 switch (IK.getLanguage()) {
473 case clang::Language::Unknown:
474 case clang::Language::LLVM_IR:
475 case clang::Language::RenderScript:
476 llvm_unreachable("Invalid input kind!")__builtin_unreachable();
477 case clang::Language::OpenCL:
478 LangStd = LangStandard::lang_opencl10;
479 break;
480 case clang::Language::OpenCLCXX:
481 LangStd = LangStandard::lang_openclcpp;
482 break;
483 case clang::Language::CUDA:
484 LangStd = LangStandard::lang_cuda;
485 break;
486 case clang::Language::Asm:
487 case clang::Language::C:
488 case clang::Language::ObjC:
489 LangStd = LangStandard::lang_gnu99;
490 break;
491 case clang::Language::CXX:
492 case clang::Language::ObjCXX:
493 LangStd = LangStandard::lang_gnucxx98;
494 break;
495 case clang::Language::HIP:
496 LangStd = LangStandard::lang_hip;
497 break;
498 }
499 }
500
501 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
502 Opts.LineComment = Std.hasLineComments();
503 Opts.C99 = Std.isC99();
504 Opts.CPlusPlus = Std.isCPlusPlus();
505 Opts.CPlusPlus11 = Std.isCPlusPlus11();
506 Opts.Digraphs = Std.hasDigraphs();
507 Opts.GNUMode = Std.isGNUMode();
508 Opts.GNUInline = !Std.isC99();
509 Opts.HexFloats = Std.hasHexFloats();
510 Opts.ImplicitInt = Std.hasImplicitInt();
511
512 Opts.WChar = true;
513
514 // OpenCL has some additional defaults.
515 if (LangStd == LangStandard::lang_opencl10) {
516 Opts.OpenCL = 1;
517 Opts.AltiVec = 1;
518 Opts.CXXOperatorNames = 1;
519 Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::All);
520 }
521
522 // OpenCL and C++ both have bool, true, false keywords.
523 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
524
525 Opts.setValueVisibilityMode(DefaultVisibility);
526
527 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs is
528 // specified, or -std is set to a conforming mode.
529 Opts.Trigraphs = !Opts.GNUMode;
530 Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault();
531 Opts.OptimizeSize = 0;
532
533 // FIXME: Eliminate this dependency.
534 // unsigned Opt =
535 // Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
536 // Opts.Optimize = Opt != 0;
537 unsigned Opt = 0;
538
539 // This is the __NO_INLINE__ define, which just depends on things like the
540 // optimization level and -fno-inline, not actually whether the backend has
541 // inlining enabled.
542 //
543 // FIXME: This is affected by other options (-fno-inline).
544 Opts.NoInlineDefine = !Opt;
545
546 // This is needed to allocate the extra space for the owning module
547 // on each decl.
548 Opts.ModulesLocalVisibility = 1;
549}
550
551TypeSystemClang::TypeSystemClang(llvm::StringRef name,
552 llvm::Triple target_triple) {
553 m_display_name = name.str();
554 if (!target_triple.str().empty())
555 SetTargetTriple(target_triple.str());
556 // The caller didn't pass an ASTContext so create a new one for this
557 // TypeSystemClang.
558 CreateASTContext();
559}
560
561TypeSystemClang::TypeSystemClang(llvm::StringRef name,
562 ASTContext &existing_ctxt) {
563 m_display_name = name.str();
564 SetTargetTriple(existing_ctxt.getTargetInfo().getTriple().str());
565
566 m_ast_up.reset(&existing_ctxt);
567 GetASTMap().Insert(&existing_ctxt, this);
568}
569
570// Destructor
571TypeSystemClang::~TypeSystemClang() { Finalize(); }
572
573ConstString TypeSystemClang::GetPluginNameStatic() {
574 return ConstString("clang");
575}
576
577ConstString TypeSystemClang::GetPluginName() {
578 return TypeSystemClang::GetPluginNameStatic();
579}
580
581uint32_t TypeSystemClang::GetPluginVersion() { return 1; }
582
583lldb::TypeSystemSP TypeSystemClang::CreateInstance(lldb::LanguageType language,
584 lldb_private::Module *module,
585 Target *target) {
586 if (!TypeSystemClangSupportsLanguage(language))
587 return lldb::TypeSystemSP();
588 ArchSpec arch;
589 if (module)
590 arch = module->GetArchitecture();
591 else if (target)
592 arch = target->GetArchitecture();
593
594 if (!arch.IsValid())
595 return lldb::TypeSystemSP();
596
597 llvm::Triple triple = arch.GetTriple();
598 // LLVM wants this to be set to iOS or MacOSX; if we're working on
599 // a bare-boards type image, change the triple for llvm's benefit.
600 if (triple.getVendor() == llvm::Triple::Apple &&
601 triple.getOS() == llvm::Triple::UnknownOS) {
602 if (triple.getArch() == llvm::Triple::arm ||
603 triple.getArch() == llvm::Triple::aarch64 ||
604 triple.getArch() == llvm::Triple::aarch64_32 ||
605 triple.getArch() == llvm::Triple::thumb) {
606 triple.setOS(llvm::Triple::IOS);
607 } else {
608 triple.setOS(llvm::Triple::MacOSX);
609 }
610 }
611
612 if (module) {
613 std::string ast_name =
614 "ASTContext for '" + module->GetFileSpec().GetPath() + "'";
615 return std::make_shared<TypeSystemClang>(ast_name, triple);
616 } else if (target && target->IsValid())
617 return std::make_shared<ScratchTypeSystemClang>(*target, triple);
618 return lldb::TypeSystemSP();
619}
620
621LanguageSet TypeSystemClang::GetSupportedLanguagesForTypes() {
622 LanguageSet languages;
623 languages.Insert(lldb::eLanguageTypeC89);
624 languages.Insert(lldb::eLanguageTypeC);
625 languages.Insert(lldb::eLanguageTypeC11);
626 languages.Insert(lldb::eLanguageTypeC_plus_plus);
627 languages.Insert(lldb::eLanguageTypeC99);
628 languages.Insert(lldb::eLanguageTypeObjC);
629 languages.Insert(lldb::eLanguageTypeObjC_plus_plus);
630 languages.Insert(lldb::eLanguageTypeC_plus_plus_03);
631 languages.Insert(lldb::eLanguageTypeC_plus_plus_11);
632 languages.Insert(lldb::eLanguageTypeC11);
633 languages.Insert(lldb::eLanguageTypeC_plus_plus_14);
634 return languages;
635}
636
637LanguageSet TypeSystemClang::GetSupportedLanguagesForExpressions() {
638 LanguageSet languages;
639 languages.Insert(lldb::eLanguageTypeC_plus_plus);
640 languages.Insert(lldb::eLanguageTypeObjC_plus_plus);
641 languages.Insert(lldb::eLanguageTypeC_plus_plus_03);
642 languages.Insert(lldb::eLanguageTypeC_plus_plus_11);
643 languages.Insert(lldb::eLanguageTypeC_plus_plus_14);
644 return languages;
645}
646
647void TypeSystemClang::Initialize() {
648 PluginManager::RegisterPlugin(
649 GetPluginNameStatic(), "clang base AST context plug-in", CreateInstance,
650 GetSupportedLanguagesForTypes(), GetSupportedLanguagesForExpressions());
651}
652
653void TypeSystemClang::Terminate() {
654 PluginManager::UnregisterPlugin(CreateInstance);
655}
656
657void TypeSystemClang::Finalize() {
658 assert(m_ast_up)((void)0);
659 GetASTMap().Erase(m_ast_up.get());
660 if (!m_ast_owned)
661 m_ast_up.release();
662
663 m_builtins_up.reset();
664 m_selector_table_up.reset();
665 m_identifier_table_up.reset();
666 m_target_info_up.reset();
667 m_target_options_rp.reset();
668 m_diagnostics_engine_up.reset();
669 m_source_manager_up.reset();
670 m_language_options_up.reset();
671}
672
673void TypeSystemClang::setSema(Sema *s) {
674 // Ensure that the new sema actually belongs to our ASTContext.
675 assert(s == nullptr || &s->getASTContext() == m_ast_up.get())((void)0);
676 m_sema = s;
677}
678
679const char *TypeSystemClang::GetTargetTriple() {
680 return m_target_triple.c_str();
681}
682
683void TypeSystemClang::SetTargetTriple(llvm::StringRef target_triple) {
684 m_target_triple = target_triple.str();
685}
686
687void TypeSystemClang::SetExternalSource(
688 llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_up) {
689 ASTContext &ast = getASTContext();
690 ast.getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
691 ast.setExternalSource(ast_source_up);
692}
693
694ASTContext &TypeSystemClang::getASTContext() {
695 assert(m_ast_up)((void)0);
696 return *m_ast_up;
697}
698
699class NullDiagnosticConsumer : public DiagnosticConsumer {
700public:
701 NullDiagnosticConsumer() {
702 m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8));
703 }
704
705 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
706 const clang::Diagnostic &info) override {
707 if (m_log) {
708 llvm::SmallVector<char, 32> diag_str(10);
709 info.FormatDiagnostic(diag_str);
710 diag_str.push_back('\0');
711 LLDB_LOGF(m_log, "Compiler diagnostic: %s\n", diag_str.data())do { ::lldb_private::Log *log_private = (m_log); if (log_private
) log_private->Printf("Compiler diagnostic: %s\n", diag_str
.data()); } while (0)
;
712 }
713 }
714
715 DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
716 return new NullDiagnosticConsumer();
717 }
718
719private:
720 Log *m_log;
721};
722
723void TypeSystemClang::CreateASTContext() {
724 assert(!m_ast_up)((void)0);
725 m_ast_owned = true;
726
727 m_language_options_up = std::make_unique<LangOptions>();
728 ParseLangArgs(*m_language_options_up, clang::Language::ObjCXX,
729 GetTargetTriple());
730
731 m_identifier_table_up =
732 std::make_unique<IdentifierTable>(*m_language_options_up, nullptr);
733 m_builtins_up = std::make_unique<Builtin::Context>();
734
735 m_selector_table_up = std::make_unique<SelectorTable>();
736
737 clang::FileSystemOptions file_system_options;
738 m_file_manager_up = std::make_unique<clang::FileManager>(
739 file_system_options, FileSystem::Instance().GetVirtualFileSystem());
740
741 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
742 m_diagnostics_engine_up =
743 std::make_unique<DiagnosticsEngine>(diag_id_sp, new DiagnosticOptions());
744
745 m_source_manager_up = std::make_unique<clang::SourceManager>(
746 *m_diagnostics_engine_up, *m_file_manager_up);
747 m_ast_up = std::make_unique<ASTContext>(
748 *m_language_options_up, *m_source_manager_up, *m_identifier_table_up,
749 *m_selector_table_up, *m_builtins_up, TU_Complete);
750
751 m_diagnostic_consumer_up = std::make_unique<NullDiagnosticConsumer>();
752 m_ast_up->getDiagnostics().setClient(m_diagnostic_consumer_up.get(), false);
753
754 // This can be NULL if we don't know anything about the architecture or if
755 // the target for an architecture isn't enabled in the llvm/clang that we
756 // built
757 TargetInfo *target_info = getTargetInfo();
758 if (target_info)
759 m_ast_up->InitBuiltinTypes(*target_info);
760
761 GetASTMap().Insert(m_ast_up.get(), this);
762
763 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up(
764 new ClangExternalASTSourceCallbacks(*this));
765 SetExternalSource(ast_source_up);
766}
767
768TypeSystemClang *TypeSystemClang::GetASTContext(clang::ASTContext *ast) {
769 TypeSystemClang *clang_ast = GetASTMap().Lookup(ast);
770 return clang_ast;
771}
772
773clang::MangleContext *TypeSystemClang::getMangleContext() {
774 if (m_mangle_ctx_up == nullptr)
775 m_mangle_ctx_up.reset(getASTContext().createMangleContext());
776 return m_mangle_ctx_up.get();
777}
778
779std::shared_ptr<clang::TargetOptions> &TypeSystemClang::getTargetOptions() {
780 if (m_target_options_rp == nullptr && !m_target_triple.empty()) {
781 m_target_options_rp = std::make_shared<clang::TargetOptions>();
782 if (m_target_options_rp != nullptr)
783 m_target_options_rp->Triple = m_target_triple;
784 }
785 return m_target_options_rp;
786}
787
788TargetInfo *TypeSystemClang::getTargetInfo() {
789 // target_triple should be something like "x86_64-apple-macosx"
790 if (m_target_info_up == nullptr && !m_target_triple.empty())
791 m_target_info_up.reset(TargetInfo::CreateTargetInfo(
792 getASTContext().getDiagnostics(), getTargetOptions()));
793 return m_target_info_up.get();
794}
795
796#pragma mark Basic Types
797
798static inline bool QualTypeMatchesBitSize(const uint64_t bit_size,
799 ASTContext &ast, QualType qual_type) {
800 uint64_t qual_type_bit_size = ast.getTypeSize(qual_type);
801 return qual_type_bit_size == bit_size;
802}
803
804CompilerType
805TypeSystemClang::GetBuiltinTypeForEncodingAndBitSize(Encoding encoding,
806 size_t bit_size) {
807 ASTContext &ast = getASTContext();
808 switch (encoding) {
809 case eEncodingInvalid:
810 if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy))
811 return GetType(ast.VoidPtrTy);
812 break;
813
814 case eEncodingUint:
815 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
816 return GetType(ast.UnsignedCharTy);
817 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
818 return GetType(ast.UnsignedShortTy);
819 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
820 return GetType(ast.UnsignedIntTy);
821 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
822 return GetType(ast.UnsignedLongTy);
823 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
824 return GetType(ast.UnsignedLongLongTy);
825 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
826 return GetType(ast.UnsignedInt128Ty);
827 break;
828
829 case eEncodingSint:
830 if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
831 return GetType(ast.SignedCharTy);
832 if (QualTypeMatchesBitSize(bit_size, ast, ast.ShortTy))
833 return GetType(ast.ShortTy);
834 if (QualTypeMatchesBitSize(bit_size, ast, ast.IntTy))
835 return GetType(ast.IntTy);
836 if (QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
837 return GetType(ast.LongTy);
838 if (QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
839 return GetType(ast.LongLongTy);
840 if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
841 return GetType(ast.Int128Ty);
842 break;
843
844 case eEncodingIEEE754:
845 if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
846 return GetType(ast.FloatTy);
847 if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
848 return GetType(ast.DoubleTy);
849 if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
850 return GetType(ast.LongDoubleTy);
851 if (QualTypeMatchesBitSize(bit_size, ast, ast.HalfTy))
852 return GetType(ast.HalfTy);
853 break;
854
855 case eEncodingVector:
856 // Sanity check that bit_size is a multiple of 8's.
857 if (bit_size && !(bit_size & 0x7u))
858 return GetType(ast.getExtVectorType(ast.UnsignedCharTy, bit_size / 8));
859 break;
860 }
861
862 return CompilerType();
863}
864
865lldb::BasicType
866TypeSystemClang::GetBasicTypeEnumeration(ConstString name) {
867 if (name) {
868 typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
869 static TypeNameToBasicTypeMap g_type_map;
870 static llvm::once_flag g_once_flag;
871 llvm::call_once(g_once_flag, []() {
872 // "void"
873 g_type_map.Append(ConstString("void"), eBasicTypeVoid);
874
875 // "char"
876 g_type_map.Append(ConstString("char"), eBasicTypeChar);
877 g_type_map.Append(ConstString("signed char"), eBasicTypeSignedChar);
878 g_type_map.Append(ConstString("unsigned char"), eBasicTypeUnsignedChar);
879 g_type_map.Append(ConstString("wchar_t"), eBasicTypeWChar);
880 g_type_map.Append(ConstString("signed wchar_t"), eBasicTypeSignedWChar);
881 g_type_map.Append(ConstString("unsigned wchar_t"),
882 eBasicTypeUnsignedWChar);
883 // "short"
884 g_type_map.Append(ConstString("short"), eBasicTypeShort);
885 g_type_map.Append(ConstString("short int"), eBasicTypeShort);
886 g_type_map.Append(ConstString("unsigned short"), eBasicTypeUnsignedShort);
887 g_type_map.Append(ConstString("unsigned short int"),
888 eBasicTypeUnsignedShort);
889
890 // "int"
891 g_type_map.Append(ConstString("int"), eBasicTypeInt);
892 g_type_map.Append(ConstString("signed int"), eBasicTypeInt);
893 g_type_map.Append(ConstString("unsigned int"), eBasicTypeUnsignedInt);
894 g_type_map.Append(ConstString("unsigned"), eBasicTypeUnsignedInt);
895
896 // "long"
897 g_type_map.Append(ConstString("long"), eBasicTypeLong);
898 g_type_map.Append(ConstString("long int"), eBasicTypeLong);
899 g_type_map.Append(ConstString("unsigned long"), eBasicTypeUnsignedLong);
900 g_type_map.Append(ConstString("unsigned long int"),
901 eBasicTypeUnsignedLong);
902
903 // "long long"
904 g_type_map.Append(ConstString("long long"), eBasicTypeLongLong);
905 g_type_map.Append(ConstString("long long int"), eBasicTypeLongLong);
906 g_type_map.Append(ConstString("unsigned long long"),
907 eBasicTypeUnsignedLongLong);
908 g_type_map.Append(ConstString("unsigned long long int"),
909 eBasicTypeUnsignedLongLong);
910
911 // "int128"
912 g_type_map.Append(ConstString("__int128_t"), eBasicTypeInt128);
913 g_type_map.Append(ConstString("__uint128_t"), eBasicTypeUnsignedInt128);
914
915 // Miscellaneous
916 g_type_map.Append(ConstString("bool"), eBasicTypeBool);
917 g_type_map.Append(ConstString("float"), eBasicTypeFloat);
918 g_type_map.Append(ConstString("double"), eBasicTypeDouble);
919 g_type_map.Append(ConstString("long double"), eBasicTypeLongDouble);
920 g_type_map.Append(ConstString("id"), eBasicTypeObjCID);
921 g_type_map.Append(ConstString("SEL"), eBasicTypeObjCSel);
922 g_type_map.Append(ConstString("nullptr"), eBasicTypeNullPtr);
923 g_type_map.Sort();
924 });
925
926 return g_type_map.Find(name, eBasicTypeInvalid);
927 }
928 return eBasicTypeInvalid;
929}
930
931uint32_t TypeSystemClang::GetPointerByteSize() {
932 if (m_pointer_byte_size == 0)
933 if (auto size = GetBasicType(lldb::eBasicTypeVoid)
934 .GetPointerType()
935 .GetByteSize(nullptr))
936 m_pointer_byte_size = *size;
937 return m_pointer_byte_size;
938}
939
940CompilerType TypeSystemClang::GetBasicType(lldb::BasicType basic_type) {
941 clang::ASTContext &ast = getASTContext();
942
943 lldb::opaque_compiler_type_t clang_type =
944 GetOpaqueCompilerType(&ast, basic_type);
945
946 if (clang_type)
947 return CompilerType(this, clang_type);
948 return CompilerType();
949}
950
951CompilerType TypeSystemClang::GetBuiltinTypeForDWARFEncodingAndBitSize(
952 llvm::StringRef type_name, uint32_t dw_ate, uint32_t bit_size) {
953 ASTContext &ast = getASTContext();
954
955 switch (dw_ate) {
956 default:
957 break;
958
959 case DW_ATE_address:
960 if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy))
961 return GetType(ast.VoidPtrTy);
962 break;
963
964 case DW_ATE_boolean:
965 if (QualTypeMatchesBitSize(bit_size, ast, ast.BoolTy))
966 return GetType(ast.BoolTy);
967 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
968 return GetType(ast.UnsignedCharTy);
969 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
970 return GetType(ast.UnsignedShortTy);
971 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
972 return GetType(ast.UnsignedIntTy);
973 break;
974
975 case DW_ATE_lo_user:
976 // This has been seen to mean DW_AT_complex_integer
977 if (type_name.contains("complex")) {
978 CompilerType complex_int_clang_type =
979 GetBuiltinTypeForDWARFEncodingAndBitSize("int", DW_ATE_signed,
980 bit_size / 2);
981 return GetType(
982 ast.getComplexType(ClangUtil::GetQualType(complex_int_clang_type)));
983 }
984 break;
985
986 case DW_ATE_complex_float:
987 if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatComplexTy))
988 return GetType(ast.FloatComplexTy);
989 else if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleComplexTy))
990 return GetType(ast.DoubleComplexTy);
991 else if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleComplexTy))
992 return GetType(ast.LongDoubleComplexTy);
993 else {
994 CompilerType complex_float_clang_type =
995 GetBuiltinTypeForDWARFEncodingAndBitSize("float", DW_ATE_float,
996 bit_size / 2);
997 return GetType(
998 ast.getComplexType(ClangUtil::GetQualType(complex_float_clang_type)));
999 }
1000 break;
1001
1002 case DW_ATE_float:
1003 if (type_name == "float" &&
1004 QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
1005 return GetType(ast.FloatTy);
1006 if (type_name == "double" &&
1007 QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
1008 return GetType(ast.DoubleTy);
1009 if (type_name == "long double" &&
1010 QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
1011 return GetType(ast.LongDoubleTy);
1012 // Fall back to not requiring a name match
1013 if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
1014 return GetType(ast.FloatTy);
1015 if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
1016 return GetType(ast.DoubleTy);
1017 if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
1018 return GetType(ast.LongDoubleTy);
1019 if (QualTypeMatchesBitSize(bit_size, ast, ast.HalfTy))
1020 return GetType(ast.HalfTy);
1021 break;
1022
1023 case DW_ATE_signed:
1024 if (!type_name.empty()) {
1025 if (type_name == "wchar_t" &&
1026 QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy) &&
1027 (getTargetInfo() &&
1028 TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
1029 return GetType(ast.WCharTy);
1030 if (type_name == "void" &&
1031 QualTypeMatchesBitSize(bit_size, ast, ast.VoidTy))
1032 return GetType(ast.VoidTy);
1033 if (type_name.contains("long long") &&
1034 QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
1035 return GetType(ast.LongLongTy);
1036 if (type_name.contains("long") &&
1037 QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
1038 return GetType(ast.LongTy);
1039 if (type_name.contains("short") &&
1040 QualTypeMatchesBitSize(bit_size, ast, ast.ShortTy))
1041 return GetType(ast.ShortTy);
1042 if (type_name.contains("char")) {
1043 if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1044 return GetType(ast.CharTy);
1045 if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
1046 return GetType(ast.SignedCharTy);
1047 }
1048 if (type_name.contains("int")) {
1049 if (QualTypeMatchesBitSize(bit_size, ast, ast.IntTy))
1050 return GetType(ast.IntTy);
1051 if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
1052 return GetType(ast.Int128Ty);
1053 }
1054 }
1055 // We weren't able to match up a type name, just search by size
1056 if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1057 return GetType(ast.CharTy);
1058 if (QualTypeMatchesBitSize(bit_size, ast, ast.ShortTy))
1059 return GetType(ast.ShortTy);
1060 if (QualTypeMatchesBitSize(bit_size, ast, ast.IntTy))
1061 return GetType(ast.IntTy);
1062 if (QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
1063 return GetType(ast.LongTy);
1064 if (QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
1065 return GetType(ast.LongLongTy);
1066 if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
1067 return GetType(ast.Int128Ty);
1068 break;
1069
1070 case DW_ATE_signed_char:
1071 if (ast.getLangOpts().CharIsSigned && type_name == "char") {
1072 if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1073 return GetType(ast.CharTy);
1074 }
1075 if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
1076 return GetType(ast.SignedCharTy);
1077 break;
1078
1079 case DW_ATE_unsigned:
1080 if (!type_name.empty()) {
1081 if (type_name == "wchar_t") {
1082 if (QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy)) {
1083 if (!(getTargetInfo() &&
1084 TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
1085 return GetType(ast.WCharTy);
1086 }
1087 }
1088 if (type_name.contains("long long")) {
1089 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
1090 return GetType(ast.UnsignedLongLongTy);
1091 } else if (type_name.contains("long")) {
1092 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
1093 return GetType(ast.UnsignedLongTy);
1094 } else if (type_name.contains("short")) {
1095 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
1096 return GetType(ast.UnsignedShortTy);
1097 } else if (type_name.contains("char")) {
1098 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
1099 return GetType(ast.UnsignedCharTy);
1100 } else if (type_name.contains("int")) {
1101 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
1102 return GetType(ast.UnsignedIntTy);
1103 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
1104 return GetType(ast.UnsignedInt128Ty);
1105 }
1106 }
1107 // We weren't able to match up a type name, just search by size
1108 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
1109 return GetType(ast.UnsignedCharTy);
1110 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
1111 return GetType(ast.UnsignedShortTy);
1112 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
1113 return GetType(ast.UnsignedIntTy);
1114 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
1115 return GetType(ast.UnsignedLongTy);
1116 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
1117 return GetType(ast.UnsignedLongLongTy);
1118 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
1119 return GetType(ast.UnsignedInt128Ty);
1120 break;
1121
1122 case DW_ATE_unsigned_char:
1123 if (!ast.getLangOpts().CharIsSigned && type_name == "char") {
1124 if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1125 return GetType(ast.CharTy);
1126 }
1127 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
1128 return GetType(ast.UnsignedCharTy);
1129 if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
1130 return GetType(ast.UnsignedShortTy);
1131 break;
1132
1133 case DW_ATE_imaginary_float:
1134 break;
1135
1136 case DW_ATE_UTF:
1137 switch (bit_size) {
1138 case 8:
1139 return GetType(ast.Char8Ty);
1140 case 16:
1141 return GetType(ast.Char16Ty);
1142 case 32:
1143 return GetType(ast.Char32Ty);
1144 default:
1145 if (!type_name.empty()) {
1146 if (type_name == "char16_t")
1147 return GetType(ast.Char16Ty);
1148 if (type_name == "char32_t")
1149 return GetType(ast.Char32Ty);
1150 if (type_name == "char8_t")
1151 return GetType(ast.Char8Ty);
1152 }
1153 }
1154 break;
1155 }
1156 // This assert should fire for anything that we don't catch above so we know
1157 // to fix any issues we run into.
1158 if (!type_name.empty()) {
1159 std::string type_name_str = type_name.str();
1160 Host::SystemLog(Host::eSystemLogError,
1161 "error: need to add support for DW_TAG_base_type '%s' "
1162 "encoded with DW_ATE = 0x%x, bit_size = %u\n",
1163 type_name_str.c_str(), dw_ate, bit_size);
1164 } else {
1165 Host::SystemLog(Host::eSystemLogError, "error: need to add support for "
1166 "DW_TAG_base_type encoded with "
1167 "DW_ATE = 0x%x, bit_size = %u\n",
1168 dw_ate, bit_size);
1169 }
1170 return CompilerType();
1171}
1172
1173CompilerType TypeSystemClang::GetCStringType(bool is_const) {
1174 ASTContext &ast = getASTContext();
1175 QualType char_type(ast.CharTy);
1176
1177 if (is_const)
1178 char_type.addConst();
1179
1180 return GetType(ast.getPointerType(char_type));
1181}
1182
1183bool TypeSystemClang::AreTypesSame(CompilerType type1, CompilerType type2,
1184 bool ignore_qualifiers) {
1185 TypeSystemClang *ast =
1186 llvm::dyn_cast_or_null<TypeSystemClang>(type1.GetTypeSystem());
1187 if (!ast || ast != type2.GetTypeSystem())
1188 return false;
1189
1190 if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
1191 return true;
1192
1193 QualType type1_qual = ClangUtil::GetQualType(type1);
1194 QualType type2_qual = ClangUtil::GetQualType(type2);
1195
1196 if (ignore_qualifiers) {
1197 type1_qual = type1_qual.getUnqualifiedType();
1198 type2_qual = type2_qual.getUnqualifiedType();
1199 }
1200
1201 return ast->getASTContext().hasSameType(type1_qual, type2_qual);
1202}
1203
1204CompilerType TypeSystemClang::GetTypeForDecl(void *opaque_decl) {
1205 if (!opaque_decl)
1206 return CompilerType();
1207
1208 clang::Decl *decl = static_cast<clang::Decl *>(opaque_decl);
1209 if (auto *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl))
1210 return GetTypeForDecl(named_decl);
1211 return CompilerType();
1212}
1213
1214CompilerDeclContext TypeSystemClang::CreateDeclContext(DeclContext *ctx) {
1215 // Check that the DeclContext actually belongs to this ASTContext.
1216 assert(&ctx->getParentASTContext() == &getASTContext())((void)0);
1217 return CompilerDeclContext(this, ctx);
1218}
1219
1220CompilerType TypeSystemClang::GetTypeForDecl(clang::NamedDecl *decl) {
1221 if (clang::ObjCInterfaceDecl *interface_decl =
1222 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
1223 return GetTypeForDecl(interface_decl);
1224 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
1225 return GetTypeForDecl(tag_decl);
1226 return CompilerType();
1227}
1228
1229CompilerType TypeSystemClang::GetTypeForDecl(TagDecl *decl) {
1230 return GetType(getASTContext().getTagDeclType(decl));
1231}
1232
1233CompilerType TypeSystemClang::GetTypeForDecl(ObjCInterfaceDecl *decl) {
1234 return GetType(getASTContext().getObjCInterfaceType(decl));
1235}
1236
1237#pragma mark Structure, Unions, Classes
1238
1239void TypeSystemClang::SetOwningModule(clang::Decl *decl,
1240 OptionalClangModuleID owning_module) {
1241 if (!decl || !owning_module.HasValue())
1242 return;
1243
1244 decl->setFromASTFile();
1245 decl->setOwningModuleID(owning_module.GetValue());
1246 decl->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
1247}
1248
1249OptionalClangModuleID
1250TypeSystemClang::GetOrCreateClangModule(llvm::StringRef name,
1251 OptionalClangModuleID parent,
1252 bool is_framework, bool is_explicit) {
1253 // Get the external AST source which holds the modules.
1254 auto *ast_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>(
1255 getASTContext().getExternalSource());
1256 assert(ast_source && "external ast source was lost")((void)0);
1257 if (!ast_source)
1258 return {};
1259
1260 // Lazily initialize the module map.
1261 if (!m_header_search_up) {
1262 auto HSOpts = std::make_shared<clang::HeaderSearchOptions>();
1263 m_header_search_up = std::make_unique<clang::HeaderSearch>(
1264 HSOpts, *m_source_manager_up, *m_diagnostics_engine_up,
1265 *m_language_options_up, m_target_info_up.get());
1266 m_module_map_up = std::make_unique<clang::ModuleMap>(
1267 *m_source_manager_up, *m_diagnostics_engine_up, *m_language_options_up,
1268 m_target_info_up.get(), *m_header_search_up);
1269 }
1270
1271 // Get or create the module context.
1272 bool created;
1273 clang::Module *module;
1274 auto parent_desc = ast_source->getSourceDescriptor(parent.GetValue());
1275 std::tie(module, created) = m_module_map_up->findOrCreateModule(
1276 name, parent_desc ? parent_desc->getModuleOrNull() : nullptr,
1277 is_framework, is_explicit);
1278 if (!created)
1279 return ast_source->GetIDForModule(module);
1280
1281 return ast_source->RegisterModule(module);
1282}
1283
1284CompilerType TypeSystemClang::CreateRecordType(
1285 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1286 AccessType access_type, llvm::StringRef name, int kind,
1287 LanguageType language, ClangASTMetadata *metadata, bool exports_symbols) {
1288 ASTContext &ast = getASTContext();
1289
1290 if (decl_ctx == nullptr)
1291 decl_ctx = ast.getTranslationUnitDecl();
1292
1293 if (language == eLanguageTypeObjC ||
1294 language == eLanguageTypeObjC_plus_plus) {
1295 bool isForwardDecl = true;
1296 bool isInternal = false;
1297 return CreateObjCClass(name, decl_ctx, owning_module, isForwardDecl,
1298 isInternal, metadata);
1299 }
1300
1301 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1302 // we will need to update this code. I was told to currently always use the
1303 // CXXRecordDecl class since we often don't know from debug information if
1304 // something is struct or a class, so we default to always use the more
1305 // complete definition just in case.
1306
1307 bool has_name = !name.empty();
1308 CXXRecordDecl *decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1309 decl->setTagKind(static_cast<TagDecl::TagKind>(kind));
1310 decl->setDeclContext(decl_ctx);
1311 if (has_name)
1312 decl->setDeclName(&ast.Idents.get(name));
1313 SetOwningModule(decl, owning_module);
1314
1315 if (!has_name) {
1316 // In C++ a lambda is also represented as an unnamed class. This is
1317 // different from an *anonymous class* that the user wrote:
1318 //
1319 // struct A {
1320 // // anonymous class (GNU/MSVC extension)
1321 // struct {
1322 // int x;
1323 // };
1324 // // unnamed class within a class
1325 // struct {
1326 // int y;
1327 // } B;
1328 // };
1329 //
1330 // void f() {
1331 // // unammed class outside of a class
1332 // struct {
1333 // int z;
1334 // } C;
1335 // }
1336 //
1337 // Anonymous classes is a GNU/MSVC extension that clang supports. It
1338 // requires the anonymous class be embedded within a class. So the new
1339 // heuristic verifies this condition.
1340 if (isa<CXXRecordDecl>(decl_ctx) && exports_symbols)
1341 decl->setAnonymousStructOrUnion(true);
1342 }
1343
1344 if (decl) {
1345 if (metadata)
1346 SetMetadata(decl, *metadata);
1347
1348 if (access_type != eAccessNone)
1349 decl->setAccess(ConvertAccessTypeToAccessSpecifier(access_type));
1350
1351 if (decl_ctx)
1352 decl_ctx->addDecl(decl);
1353
1354 return GetType(ast.getTagDeclType(decl));
1355 }
1356 return CompilerType();
1357}
1358
1359namespace {
1360/// Returns true iff the given TemplateArgument should be represented as an
1361/// NonTypeTemplateParmDecl in the AST.
1362bool IsValueParam(const clang::TemplateArgument &argument) {
1363 return argument.getKind() == TemplateArgument::Integral;
1364}
1365}
1366
1367static TemplateParameterList *CreateTemplateParameterList(
1368 ASTContext &ast,
1369 const TypeSystemClang::TemplateParameterInfos &template_param_infos,
1370 llvm::SmallVector<NamedDecl *, 8> &template_param_decls) {
1371 const bool parameter_pack = false;
1372 const bool is_typename = false;
1373 const unsigned depth = 0;
1374 const size_t num_template_params = template_param_infos.args.size();
1375 DeclContext *const decl_context =
1376 ast.getTranslationUnitDecl(); // Is this the right decl context?,
1377 for (size_t i = 0; i < num_template_params; ++i) {
1378 const char *name = template_param_infos.names[i];
1379
1380 IdentifierInfo *identifier_info = nullptr;
1381 if (name && name[0])
1382 identifier_info = &ast.Idents.get(name);
1383 if (IsValueParam(template_param_infos.args[i])) {
1384 QualType template_param_type =
1385 template_param_infos.args[i].getIntegralType();
1386 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1387 ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1388 identifier_info, template_param_type, parameter_pack,
1389 ast.getTrivialTypeSourceInfo(template_param_type)));
1390 } else {
1391 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1392 ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1393 identifier_info, is_typename, parameter_pack));
1394 }
1395 }
1396
1397 if (template_param_infos.packed_args) {
1398 IdentifierInfo *identifier_info = nullptr;
1399 if (template_param_infos.pack_name && template_param_infos.pack_name[0])
1400 identifier_info = &ast.Idents.get(template_param_infos.pack_name);
1401 const bool parameter_pack_true = true;
1402
1403 if (!template_param_infos.packed_args->args.empty() &&
1404 IsValueParam(template_param_infos.packed_args->args[0])) {
1405 QualType template_param_type =
1406 template_param_infos.packed_args->args[0].getIntegralType();
1407 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1408 ast, decl_context, SourceLocation(), SourceLocation(), depth,
1409 num_template_params, identifier_info, template_param_type,
1410 parameter_pack_true,
1411 ast.getTrivialTypeSourceInfo(template_param_type)));
1412 } else {
1413 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1414 ast, decl_context, SourceLocation(), SourceLocation(), depth,
1415 num_template_params, identifier_info, is_typename,
1416 parameter_pack_true));
1417 }
1418 }
1419 clang::Expr *const requires_clause = nullptr; // TODO: Concepts
1420 TemplateParameterList *template_param_list = TemplateParameterList::Create(
1421 ast, SourceLocation(), SourceLocation(), template_param_decls,
1422 SourceLocation(), requires_clause);
1423 return template_param_list;
1424}
1425
1426clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl(
1427 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1428 clang::FunctionDecl *func_decl,
1429 const TemplateParameterInfos &template_param_infos) {
1430 // /// Create a function template node.
1431 ASTContext &ast = getASTContext();
1432
1433 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1434 TemplateParameterList *template_param_list = CreateTemplateParameterList(
1435 ast, template_param_infos, template_param_decls);
1436 FunctionTemplateDecl *func_tmpl_decl =
1437 FunctionTemplateDecl::CreateDeserialized(ast, 0);
1438 func_tmpl_decl->setDeclContext(decl_ctx);
1439 func_tmpl_decl->setLocation(func_decl->getLocation());
1440 func_tmpl_decl->setDeclName(func_decl->getDeclName());
1441 func_tmpl_decl->init(func_decl, template_param_list);
1442 SetOwningModule(func_tmpl_decl, owning_module);
1443
1444 for (size_t i = 0, template_param_decl_count = template_param_decls.size();
1445 i < template_param_decl_count; ++i) {
1446 // TODO: verify which decl context we should put template_param_decls into..
1447 template_param_decls[i]->setDeclContext(func_decl);
1448 }
1449 // Function templates inside a record need to have an access specifier.
1450 // It doesn't matter what access specifier we give the template as LLDB
1451 // anyway allows accessing everything inside a record.
1452 if (decl_ctx->isRecord())
1453 func_tmpl_decl->setAccess(clang::AccessSpecifier::AS_public);
1454
1455 return func_tmpl_decl;
1456}
1457
1458void TypeSystemClang::CreateFunctionTemplateSpecializationInfo(
1459 FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
1460 const TemplateParameterInfos &infos) {
1461 TemplateArgumentList *template_args_ptr =
1462 TemplateArgumentList::CreateCopy(func_decl->getASTContext(), infos.args);
1463
1464 func_decl->setFunctionTemplateSpecialization(func_tmpl_decl,
1465 template_args_ptr, nullptr);
1466}
1467
1468/// Returns true if the given template parameter can represent the given value.
1469/// For example, `typename T` can represent `int` but not integral values such
1470/// as `int I = 3`.
1471static bool TemplateParameterAllowsValue(NamedDecl *param,
1472 const TemplateArgument &value) {
1473 if (auto *type_param = llvm::dyn_cast<TemplateTypeParmDecl>(param)) {
1474 // Compare the argument kind, i.e. ensure that <typename> != <int>.
1475 if (value.getKind() != TemplateArgument::Type)
1476 return false;
1477 } else if (auto *type_param =
1478 llvm::dyn_cast<NonTypeTemplateParmDecl>(param)) {
1479 // Compare the argument kind, i.e. ensure that <typename> != <int>.
1480 if (!IsValueParam(value))
1481 return false;
1482 // Compare the integral type, i.e. ensure that <int> != <char>.
1483 if (type_param->getType() != value.getIntegralType())
1484 return false;
1485 } else {
1486 // There is no way to create other parameter decls at the moment, so we
1487 // can't reach this case during normal LLDB usage. Log that this happened
1488 // and assert.
1489 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8));
1490 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, __func__, "Don't know how to compare template parameter to passed"
" value. Decl kind of parameter is: {0}", param->getDeclKindName
()); } while (0)
1491 "Don't know how to compare template parameter to passed"do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, __func__, "Don't know how to compare template parameter to passed"
" value. Decl kind of parameter is: {0}", param->getDeclKindName
()); } while (0)
1492 " value. Decl kind of parameter is: {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, __func__, "Don't know how to compare template parameter to passed"
" value. Decl kind of parameter is: {0}", param->getDeclKindName
()); } while (0)
1493 param->getDeclKindName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, __func__, "Don't know how to compare template parameter to passed"
" value. Decl kind of parameter is: {0}", param->getDeclKindName
()); } while (0)
;
1494 lldbassert(false && "Can't compare this TemplateParmDecl subclass")lldb_private::lldb_assert(static_cast<bool>(false &&
"Can't compare this TemplateParmDecl subclass"), "false && \"Can't compare this TemplateParmDecl subclass\""
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, 1494)
;
1495 // In release builds just fall back to marking the parameter as not
1496 // accepting the value so that we don't try to fit an instantiation to a
1497 // template that doesn't fit. E.g., avoid that `S<1>` is being connected to
1498 // `template<typename T> struct S;`.
1499 return false;
1500 }
1501 return true;
1502}
1503
1504/// Returns true if the given class template declaration could produce an
1505/// instantiation with the specified values.
1506/// For example, `<typename T>` allows the arguments `float`, but not for
1507/// example `bool, float` or `3` (as an integer parameter value).
1508static bool ClassTemplateAllowsToInstantiationArgs(
1509 ClassTemplateDecl *class_template_decl,
1510 const TypeSystemClang::TemplateParameterInfos &instantiation_values) {
1511
1512 TemplateParameterList &params = *class_template_decl->getTemplateParameters();
1513
1514 // Save some work by iterating only once over the found parameters and
1515 // calculate the information related to parameter packs.
1516
1517 // Contains the first pack parameter (or non if there are none).
1518 llvm::Optional<NamedDecl *> pack_parameter;
1519 // Contains the number of non-pack parameters.
1520 size_t non_pack_params = params.size();
1521 for (size_t i = 0; i < params.size(); ++i) {
1522 NamedDecl *param = params.getParam(i);
1523 if (param->isParameterPack()) {
1524 pack_parameter = param;
1525 non_pack_params = i;
1526 break;
1527 }
1528 }
1529
1530 // The found template needs to have compatible non-pack template arguments.
1531 // E.g., ensure that <typename, typename> != <typename>.
1532 // The pack parameters are compared later.
1533 if (non_pack_params != instantiation_values.args.size())
1534 return false;
1535
1536 // Ensure that <typename...> != <typename>.
1537 if (pack_parameter.hasValue() != instantiation_values.hasParameterPack())
1538 return false;
1539
1540 // Compare the first pack parameter that was found with the first pack
1541 // parameter value. The special case of having an empty parameter pack value
1542 // always fits to a pack parameter.
1543 // E.g., ensure that <int...> != <typename...>.
1544 if (pack_parameter && !instantiation_values.packed_args->args.empty() &&
1545 !TemplateParameterAllowsValue(
1546 *pack_parameter, instantiation_values.packed_args->args.front()))
1547 return false;
1548
1549 // Compare all the non-pack parameters now.
1550 // E.g., ensure that <int> != <long>.
1551 for (const auto pair : llvm::zip_first(instantiation_values.args, params)) {
1552 const TemplateArgument &passed_arg = std::get<0>(pair);
1553 NamedDecl *found_param = std::get<1>(pair);
1554 if (!TemplateParameterAllowsValue(found_param, passed_arg))
1555 return false;
1556 }
1557
1558 return class_template_decl;
1559}
1560
1561ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl(
1562 DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1563 lldb::AccessType access_type, const char *class_name, int kind,
1564 const TemplateParameterInfos &template_param_infos) {
1565 ASTContext &ast = getASTContext();
1566
1567 ClassTemplateDecl *class_template_decl = nullptr;
1568 if (decl_ctx == nullptr)
1569 decl_ctx = ast.getTranslationUnitDecl();
1570
1571 IdentifierInfo &identifier_info = ast.Idents.get(class_name);
1572 DeclarationName decl_name(&identifier_info);
1573
1574 // Search the AST for an existing ClassTemplateDecl that could be reused.
1575 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1576 for (NamedDecl *decl : result) {
1577 class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1578 if (!class_template_decl)
1579 continue;
1580 // The class template has to be able to represents the instantiation
1581 // values we received. Without this we might end up putting an instantiation
1582 // with arguments such as <int, int> to a template such as:
1583 // template<typename T> struct S;
1584 // Connecting the instantiation to an incompatible template could cause
1585 // problems later on.
1586 if (!ClassTemplateAllowsToInstantiationArgs(class_template_decl,
1587 template_param_infos))
1588 continue;
1589 return class_template_decl;
1590 }
1591
1592 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1593
1594 TemplateParameterList *template_param_list = CreateTemplateParameterList(
1595 ast, template_param_infos, template_param_decls);
1596
1597 CXXRecordDecl *template_cxx_decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1598 template_cxx_decl->setTagKind(static_cast<TagDecl::TagKind>(kind));
1599 // What decl context do we use here? TU? The actual decl context?
1600 template_cxx_decl->setDeclContext(decl_ctx);
1601 template_cxx_decl->setDeclName(decl_name);
1602 SetOwningModule(template_cxx_decl, owning_module);
1603
1604 for (size_t i = 0, template_param_decl_count = template_param_decls.size();
1605 i < template_param_decl_count; ++i) {
1606 template_param_decls[i]->setDeclContext(template_cxx_decl);
1607 }
1608
1609 // With templated classes, we say that a class is templated with
1610 // specializations, but that the bare class has no functions.
1611 // template_cxx_decl->startDefinition();
1612 // template_cxx_decl->completeDefinition();
1613
1614 class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0);
1615 // What decl context do we use here? TU? The actual decl context?
1616 class_template_decl->setDeclContext(decl_ctx);
1617 class_template_decl->setDeclName(decl_name);
1618 class_template_decl->init(template_cxx_decl, template_param_list);
1619 template_cxx_decl->setDescribedClassTemplate(class_template_decl);
1620 SetOwningModule(class_template_decl, owning_module);
1621
1622 if (class_template_decl) {
1623 if (access_type != eAccessNone)
1624 class_template_decl->setAccess(
1625 ConvertAccessTypeToAccessSpecifier(access_type));
1626
1627 decl_ctx->addDecl(class_template_decl);
1628
1629 VerifyDecl(class_template_decl);
1630 }
1631
1632 return class_template_decl;
1633}
1634
1635TemplateTemplateParmDecl *
1636TypeSystemClang::CreateTemplateTemplateParmDecl(const char *template_name) {
1637 ASTContext &ast = getASTContext();
1638
1639 auto *decl_ctx = ast.getTranslationUnitDecl();
1640
1641 IdentifierInfo &identifier_info = ast.Idents.get(template_name);
1642 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1643
1644 TypeSystemClang::TemplateParameterInfos template_param_infos;
1645 TemplateParameterList *template_param_list = CreateTemplateParameterList(
1646 ast, template_param_infos, template_param_decls);
1647
1648 // LLDB needs to create those decls only to be able to display a
1649 // type that includes a template template argument. Only the name matters for
1650 // this purpose, so we use dummy values for the other characteristics of the
1651 // type.
1652 return TemplateTemplateParmDecl::Create(
1653 ast, decl_ctx, SourceLocation(),
1654 /*Depth*/ 0, /*Position*/ 0,
1655 /*IsParameterPack*/ false, &identifier_info, template_param_list);
1656}
1657
1658ClassTemplateSpecializationDecl *
1659TypeSystemClang::CreateClassTemplateSpecializationDecl(
1660 DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1661 ClassTemplateDecl *class_template_decl, int kind,
1662 const TemplateParameterInfos &template_param_infos) {
1663 ASTContext &ast = getASTContext();
1664 llvm::SmallVector<clang::TemplateArgument, 2> args(
1665 template_param_infos.args.size() +
1666 (template_param_infos.packed_args ? 1 : 0));
1667 std::copy(template_param_infos.args.begin(), template_param_infos.args.end(),
1668 args.begin());
1669 if (template_param_infos.packed_args) {
1670 args[args.size() - 1] = TemplateArgument::CreatePackCopy(
1671 ast, template_param_infos.packed_args->args);
1672 }
1673 ClassTemplateSpecializationDecl *class_template_specialization_decl =
1674 ClassTemplateSpecializationDecl::CreateDeserialized(ast, 0);
1675 class_template_specialization_decl->setTagKind(
1676 static_cast<TagDecl::TagKind>(kind));
1677 class_template_specialization_decl->setDeclContext(decl_ctx);
1678 class_template_specialization_decl->setInstantiationOf(class_template_decl);
1679 class_template_specialization_decl->setTemplateArgs(
1680 TemplateArgumentList::CreateCopy(ast, args));
1681 ast.getTypeDeclType(class_template_specialization_decl, nullptr);
1682 class_template_specialization_decl->setDeclName(
1683 class_template_decl->getDeclName());
1684 SetOwningModule(class_template_specialization_decl, owning_module);
1685 decl_ctx->addDecl(class_template_specialization_decl);
1686
1687 class_template_specialization_decl->setSpecializationKind(
1688 TSK_ExplicitSpecialization);
1689
1690 return class_template_specialization_decl;
1691}
1692
1693CompilerType TypeSystemClang::CreateClassTemplateSpecializationType(
1694 ClassTemplateSpecializationDecl *class_template_specialization_decl) {
1695 if (class_template_specialization_decl) {
1696 ASTContext &ast = getASTContext();
1697 return GetType(ast.getTagDeclType(class_template_specialization_decl));
1698 }
1699 return CompilerType();
1700}
1701
1702static inline bool check_op_param(bool is_method,
1703 clang::OverloadedOperatorKind op_kind,
1704 bool unary, bool binary,
1705 uint32_t num_params) {
1706 // Special-case call since it can take any number of operands
1707 if (op_kind == OO_Call)
1708 return true;
1709
1710 // The parameter count doesn't include "this"
1711 if (is_method)
1712 ++num_params;
1713 if (num_params == 1)
1714 return unary;
1715 if (num_params == 2)
1716 return binary;
1717 else
1718 return false;
1719}
1720
1721bool TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
1722 bool is_method, clang::OverloadedOperatorKind op_kind,
1723 uint32_t num_params) {
1724 switch (op_kind) {
1725 default:
1726 break;
1727 // C++ standard allows any number of arguments to new/delete
1728 case OO_New:
1729 case OO_Array_New:
1730 case OO_Delete:
1731 case OO_Array_Delete:
1732 return true;
1733 }
1734
1735#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
1736 case OO_##Name: \
1737 return check_op_param(is_method, op_kind, Unary, Binary, num_params);
1738 switch (op_kind) {
1739#include "clang/Basic/OperatorKinds.def"
1740 default:
1741 break;
1742 }
1743 return false;
1744}
1745
1746clang::AccessSpecifier
1747TypeSystemClang::UnifyAccessSpecifiers(clang::AccessSpecifier lhs,
1748 clang::AccessSpecifier rhs) {
1749 // Make the access equal to the stricter of the field and the nested field's
1750 // access
1751 if (lhs == AS_none || rhs == AS_none)
1752 return AS_none;
1753 if (lhs == AS_private || rhs == AS_private)
1754 return AS_private;
1755 if (lhs == AS_protected || rhs == AS_protected)
1756 return AS_protected;
1757 return AS_public;
1758}
1759
1760bool TypeSystemClang::FieldIsBitfield(FieldDecl *field,
1761 uint32_t &bitfield_bit_size) {
1762 ASTContext &ast = getASTContext();
1763 if (field == nullptr)
1764 return false;
1765
1766 if (field->isBitField()) {
1767 Expr *bit_width_expr = field->getBitWidth();
1768 if (bit_width_expr) {
1769 if (Optional<llvm::APSInt> bit_width_apsint =
1770 bit_width_expr->getIntegerConstantExpr(ast)) {
1771 bitfield_bit_size = bit_width_apsint->getLimitedValue(UINT32_MAX0xffffffffU);
1772 return true;
1773 }
1774 }
1775 }
1776 return false;
1777}
1778
1779bool TypeSystemClang::RecordHasFields(const RecordDecl *record_decl) {
1780 if (record_decl == nullptr)
14
Taking false branch
1781 return false;
1782
1783 if (!record_decl->field_empty())
15
Calling 'RecordDecl::field_empty'
24
Returning from 'RecordDecl::field_empty'
25
Taking false branch
1784 return true;
1785
1786 // No fields, lets check this is a CXX record and check the base classes
1787 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
26
Assuming 'record_decl' is a 'CXXRecordDecl'
1788 if (cxx_record_decl
26.1
'cxx_record_decl' is non-null
26.1
'cxx_record_decl' is non-null
26.1
'cxx_record_decl' is non-null
) {
27
Taking true branch
1789 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1790 for (base_class = cxx_record_decl->bases_begin(),
28
Loop condition is true. Entering loop body
1791 base_class_end = cxx_record_decl->bases_end();
1792 base_class != base_class_end; ++base_class) {
1793 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
1794 base_class->getType()->getAs<RecordType>()->getDecl());
29
Assuming the object is not a 'RecordType'
30
Called C++ object pointer is null
1795 if (RecordHasFields(base_class_decl))
1796 return true;
1797 }
1798 }
1799 return false;
1800}
1801
1802#pragma mark Objective-C Classes
1803
1804CompilerType TypeSystemClang::CreateObjCClass(
1805 llvm::StringRef name, clang::DeclContext *decl_ctx,
1806 OptionalClangModuleID owning_module, bool isForwardDecl, bool isInternal,
1807 ClangASTMetadata *metadata) {
1808 ASTContext &ast = getASTContext();
1809 assert(!name.empty())((void)0);
1810 if (!decl_ctx)
1811 decl_ctx = ast.getTranslationUnitDecl();
1812
1813 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0);
1814 decl->setDeclContext(decl_ctx);
1815 decl->setDeclName(&ast.Idents.get(name));
1816 /*isForwardDecl,*/
1817 decl->setImplicit(isInternal);
1818 SetOwningModule(decl, owning_module);
1819
1820 if (decl && metadata)
1821 SetMetadata(decl, *metadata);
1822
1823 return GetType(ast.getObjCInterfaceType(decl));
1824}
1825
1826static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
1827 return !TypeSystemClang::RecordHasFields(b->getType()->getAsCXXRecordDecl());
1828}
1829
1830uint32_t
1831TypeSystemClang::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
1832 bool omit_empty_base_classes) {
1833 uint32_t num_bases = 0;
1834 if (cxx_record_decl) {
1835 if (omit_empty_base_classes) {
1836 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1837 for (base_class = cxx_record_decl->bases_begin(),
1838 base_class_end = cxx_record_decl->bases_end();
1839 base_class != base_class_end; ++base_class) {
1840 // Skip empty base classes
1841 if (BaseSpecifierIsEmpty(base_class))
1842 continue;
1843 ++num_bases;
1844 }
1845 } else
1846 num_bases = cxx_record_decl->getNumBases();
1847 }
1848 return num_bases;
1849}
1850
1851#pragma mark Namespace Declarations
1852
1853NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration(
1854 const char *name, clang::DeclContext *decl_ctx,
1855 OptionalClangModuleID owning_module, bool is_inline) {
1856 NamespaceDecl *namespace_decl = nullptr;
1857 ASTContext &ast = getASTContext();
1858 TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl();
1859 if (!decl_ctx)
1860 decl_ctx = translation_unit_decl;
1861
1862 if (name) {
1863 IdentifierInfo &identifier_info = ast.Idents.get(name);
1864 DeclarationName decl_name(&identifier_info);
1865 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1866 for (NamedDecl *decl : result) {
1867 namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1868 if (namespace_decl)
1869 return namespace_decl;
1870 }
1871
1872 namespace_decl =
1873 NamespaceDecl::Create(ast, decl_ctx, is_inline, SourceLocation(),
1874 SourceLocation(), &identifier_info, nullptr);
1875
1876 decl_ctx->addDecl(namespace_decl);
1877 } else {
1878 if (decl_ctx == translation_unit_decl) {
1879 namespace_decl = translation_unit_decl->getAnonymousNamespace();
1880 if (namespace_decl)
1881 return namespace_decl;
1882
1883 namespace_decl =
1884 NamespaceDecl::Create(ast, decl_ctx, false, SourceLocation(),
1885 SourceLocation(), nullptr, nullptr);
1886 translation_unit_decl->setAnonymousNamespace(namespace_decl);
1887 translation_unit_decl->addDecl(namespace_decl);
1888 assert(namespace_decl == translation_unit_decl->getAnonymousNamespace())((void)0);
1889 } else {
1890 NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1891 if (parent_namespace_decl) {
1892 namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1893 if (namespace_decl)
1894 return namespace_decl;
1895 namespace_decl =
1896 NamespaceDecl::Create(ast, decl_ctx, false, SourceLocation(),
1897 SourceLocation(), nullptr, nullptr);
1898 parent_namespace_decl->setAnonymousNamespace(namespace_decl);
1899 parent_namespace_decl->addDecl(namespace_decl);
1900 assert(namespace_decl ==((void)0)
1901 parent_namespace_decl->getAnonymousNamespace())((void)0);
1902 } else {
1903 assert(false && "GetUniqueNamespaceDeclaration called with no name and "((void)0)
1904 "no namespace as decl_ctx")((void)0);
1905 }
1906 }
1907 }
1908 // Note: namespaces can span multiple modules, so perhaps this isn't a good
1909 // idea.
1910 SetOwningModule(namespace_decl, owning_module);
1911
1912 VerifyDecl(namespace_decl);
1913 return namespace_decl;
1914}
1915
1916clang::BlockDecl *
1917TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx,
1918 OptionalClangModuleID owning_module) {
1919 if (ctx) {
1920 clang::BlockDecl *decl =
1921 clang::BlockDecl::CreateDeserialized(getASTContext(), 0);
1922 decl->setDeclContext(ctx);
1923 ctx->addDecl(decl);
1924 SetOwningModule(decl, owning_module);
1925 return decl;
1926 }
1927 return nullptr;
1928}
1929
1930clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left,
1931 clang::DeclContext *right,
1932 clang::DeclContext *root) {
1933 if (root == nullptr)
1934 return nullptr;
1935
1936 std::set<clang::DeclContext *> path_left;
1937 for (clang::DeclContext *d = left; d != nullptr; d = d->getParent())
1938 path_left.insert(d);
1939
1940 for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
1941 if (path_left.find(d) != path_left.end())
1942 return d;
1943
1944 return nullptr;
1945}
1946
1947clang::UsingDirectiveDecl *TypeSystemClang::CreateUsingDirectiveDeclaration(
1948 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1949 clang::NamespaceDecl *ns_decl) {
1950 if (decl_ctx && ns_decl) {
1951 auto *translation_unit = getASTContext().getTranslationUnitDecl();
1952 clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
1953 getASTContext(), decl_ctx, clang::SourceLocation(),
1954 clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
1955 clang::SourceLocation(), ns_decl,
1956 FindLCABetweenDecls(decl_ctx, ns_decl,
1957 translation_unit));
1958 decl_ctx->addDecl(using_decl);
1959 SetOwningModule(using_decl, owning_module);
1960 return using_decl;
1961 }
1962 return nullptr;
1963}
1964
1965clang::UsingDecl *
1966TypeSystemClang::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
1967 OptionalClangModuleID owning_module,
1968 clang::NamedDecl *target) {
1969 if (current_decl_ctx && target) {
1970 clang::UsingDecl *using_decl = clang::UsingDecl::Create(
1971 getASTContext(), current_decl_ctx, clang::SourceLocation(),
1972 clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false);
1973 SetOwningModule(using_decl, owning_module);
1974 clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
1975 getASTContext(), current_decl_ctx, clang::SourceLocation(),
1976 target->getDeclName(), using_decl, target);
1977 SetOwningModule(shadow_decl, owning_module);
1978 using_decl->addShadowDecl(shadow_decl);
1979 current_decl_ctx->addDecl(using_decl);
1980 return using_decl;
1981 }
1982 return nullptr;
1983}
1984
1985clang::VarDecl *TypeSystemClang::CreateVariableDeclaration(
1986 clang::DeclContext *decl_context, OptionalClangModuleID owning_module,
1987 const char *name, clang::QualType type) {
1988 if (decl_context) {
1989 clang::VarDecl *var_decl =
1990 clang::VarDecl::CreateDeserialized(getASTContext(), 0);
1991 var_decl->setDeclContext(decl_context);
1992 if (name && name[0])
1993 var_decl->setDeclName(&getASTContext().Idents.getOwn(name));
1994 var_decl->setType(type);
1995 SetOwningModule(var_decl, owning_module);
1996 var_decl->setAccess(clang::AS_public);
1997 decl_context->addDecl(var_decl);
1998 return var_decl;
1999 }
2000 return nullptr;
2001}
2002
2003lldb::opaque_compiler_type_t
2004TypeSystemClang::GetOpaqueCompilerType(clang::ASTContext *ast,
2005 lldb::BasicType basic_type) {
2006 switch (basic_type) {
2007 case eBasicTypeVoid:
2008 return ast->VoidTy.getAsOpaquePtr();
2009 case eBasicTypeChar:
2010 return ast->CharTy.getAsOpaquePtr();
2011 case eBasicTypeSignedChar:
2012 return ast->SignedCharTy.getAsOpaquePtr();
2013 case eBasicTypeUnsignedChar:
2014 return ast->UnsignedCharTy.getAsOpaquePtr();
2015 case eBasicTypeWChar:
2016 return ast->getWCharType().getAsOpaquePtr();
2017 case eBasicTypeSignedWChar:
2018 return ast->getSignedWCharType().getAsOpaquePtr();
2019 case eBasicTypeUnsignedWChar:
2020 return ast->getUnsignedWCharType().getAsOpaquePtr();
2021 case eBasicTypeChar16:
2022 return ast->Char16Ty.getAsOpaquePtr();
2023 case eBasicTypeChar32:
2024 return ast->Char32Ty.getAsOpaquePtr();
2025 case eBasicTypeShort:
2026 return ast->ShortTy.getAsOpaquePtr();
2027 case eBasicTypeUnsignedShort:
2028 return ast->UnsignedShortTy.getAsOpaquePtr();
2029 case eBasicTypeInt:
2030 return ast->IntTy.getAsOpaquePtr();
2031 case eBasicTypeUnsignedInt:
2032 return ast->UnsignedIntTy.getAsOpaquePtr();
2033 case eBasicTypeLong:
2034 return ast->LongTy.getAsOpaquePtr();
2035 case eBasicTypeUnsignedLong:
2036 return ast->UnsignedLongTy.getAsOpaquePtr();
2037 case eBasicTypeLongLong:
2038 return ast->LongLongTy.getAsOpaquePtr();
2039 case eBasicTypeUnsignedLongLong:
2040 return ast->UnsignedLongLongTy.getAsOpaquePtr();
2041 case eBasicTypeInt128:
2042 return ast->Int128Ty.getAsOpaquePtr();
2043 case eBasicTypeUnsignedInt128:
2044 return ast->UnsignedInt128Ty.getAsOpaquePtr();
2045 case eBasicTypeBool:
2046 return ast->BoolTy.getAsOpaquePtr();
2047 case eBasicTypeHalf:
2048 return ast->HalfTy.getAsOpaquePtr();
2049 case eBasicTypeFloat:
2050 return ast->FloatTy.getAsOpaquePtr();
2051 case eBasicTypeDouble:
2052 return ast->DoubleTy.getAsOpaquePtr();
2053 case eBasicTypeLongDouble:
2054 return ast->LongDoubleTy.getAsOpaquePtr();
2055 case eBasicTypeFloatComplex:
2056 return ast->FloatComplexTy.getAsOpaquePtr();
2057 case eBasicTypeDoubleComplex:
2058 return ast->DoubleComplexTy.getAsOpaquePtr();
2059 case eBasicTypeLongDoubleComplex:
2060 return ast->LongDoubleComplexTy.getAsOpaquePtr();
2061 case eBasicTypeObjCID:
2062 return ast->getObjCIdType().getAsOpaquePtr();
2063 case eBasicTypeObjCClass:
2064 return ast->getObjCClassType().getAsOpaquePtr();
2065 case eBasicTypeObjCSel:
2066 return ast->getObjCSelType().getAsOpaquePtr();
2067 case eBasicTypeNullPtr:
2068 return ast->NullPtrTy.getAsOpaquePtr();
2069 default:
2070 return nullptr;
2071 }
2072}
2073
2074#pragma mark Function Types
2075
2076clang::DeclarationName
2077TypeSystemClang::GetDeclarationName(llvm::StringRef name,
2078 const CompilerType &function_clang_type) {
2079 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
2080 if (!IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS)
2081 return DeclarationName(&getASTContext().Idents.get(
2082 name)); // Not operator, but a regular function.
2083
2084 // Check the number of operator parameters. Sometimes we have seen bad DWARF
2085 // that doesn't correctly describe operators and if we try to create a method
2086 // and add it to the class, clang will assert and crash, so we need to make
2087 // sure things are acceptable.
2088 clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type));
2089 const clang::FunctionProtoType *function_type =
2090 llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
2091 if (function_type == nullptr)
2092 return clang::DeclarationName();
2093
2094 const bool is_method = false;
2095 const unsigned int num_params = function_type->getNumParams();
2096 if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
2097 is_method, op_kind, num_params))
2098 return clang::DeclarationName();
2099
2100 return getASTContext().DeclarationNames.getCXXOperatorName(op_kind);
2101}
2102
2103PrintingPolicy TypeSystemClang::GetTypePrintingPolicy() {
2104 clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
2105 printing_policy.SuppressTagKeyword = true;
2106 // Inline namespaces are important for some type formatters (e.g., libc++
2107 // and libstdc++ are differentiated by their inline namespaces).
2108 printing_policy.SuppressInlineNamespace = false;
2109 printing_policy.SuppressUnwrittenScope = false;
2110 // Default arguments are also always important for type formatters. Otherwise
2111 // we would need to always specify two type names for the setups where we do
2112 // know the default arguments and where we don't know default arguments.
2113 //
2114 // For example, without this we would need to have formatters for both:
2115 // std::basic_string<char>
2116 // and
2117 // std::basic_string<char, std::char_traits<char>, std::allocator<char> >
2118 // to support setups where LLDB was able to reconstruct default arguments
2119 // (and we then would have suppressed them from the type name) and also setups
2120 // where LLDB wasn't able to reconstruct the default arguments.
2121 printing_policy.SuppressDefaultTemplateArgs = false;
2122 return printing_policy;
2123}
2124
2125std::string TypeSystemClang::GetTypeNameForDecl(const NamedDecl *named_decl) {
2126 clang::PrintingPolicy printing_policy = GetTypePrintingPolicy();
2127 std::string result;
2128 llvm::raw_string_ostream os(result);
2129 named_decl->printQualifiedName(os, printing_policy);
2130 return result;
2131}
2132
2133FunctionDecl *TypeSystemClang::CreateFunctionDeclaration(
2134 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
2135 llvm::StringRef name, const CompilerType &function_clang_type,
2136 clang::StorageClass storage, bool is_inline) {
2137 FunctionDecl *func_decl = nullptr;
2138 ASTContext &ast = getASTContext();
2139 if (!decl_ctx)
2140 decl_ctx = ast.getTranslationUnitDecl();
2141
2142 const bool hasWrittenPrototype = true;
2143 const bool isConstexprSpecified = false;
2144
2145 clang::DeclarationName declarationName =
2146 GetDeclarationName(name, function_clang_type);
2147 func_decl = FunctionDecl::CreateDeserialized(ast, 0);
2148 func_decl->setDeclContext(decl_ctx);
2149 func_decl->setDeclName(declarationName);
2150 func_decl->setType(ClangUtil::GetQualType(function_clang_type));
2151 func_decl->setStorageClass(storage);
2152 func_decl->setInlineSpecified(is_inline);
2153 func_decl->setHasWrittenPrototype(hasWrittenPrototype);
2154 func_decl->setConstexprKind(isConstexprSpecified
2155 ? ConstexprSpecKind::Constexpr
2156 : ConstexprSpecKind::Unspecified);
2157 SetOwningModule(func_decl, owning_module);
2158 if (func_decl)
2159 decl_ctx->addDecl(func_decl);
2160
2161 VerifyDecl(func_decl);
2162
2163 return func_decl;
2164}
2165
2166CompilerType
2167TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
2168 const CompilerType *args, unsigned num_args,
2169 bool is_variadic, unsigned type_quals,
2170 clang::CallingConv cc) {
2171 if (!result_type || !ClangUtil::IsClangType(result_type))
2172 return CompilerType(); // invalid return type
2173
2174 std::vector<QualType> qual_type_args;
2175 if (num_args > 0 && args == nullptr)
2176 return CompilerType(); // invalid argument array passed in
2177
2178 // Verify that all arguments are valid and the right type
2179 for (unsigned i = 0; i < num_args; ++i) {
2180 if (args[i]) {
2181 // Make sure we have a clang type in args[i] and not a type from another
2182 // language whose name might match
2183 const bool is_clang_type = ClangUtil::IsClangType(args[i]);
2184 lldbassert(is_clang_type)lldb_private::lldb_assert(static_cast<bool>(is_clang_type
), "is_clang_type", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, 2184)
;
2185 if (is_clang_type)
2186 qual_type_args.push_back(ClangUtil::GetQualType(args[i]));
2187 else
2188 return CompilerType(); // invalid argument type (must be a clang type)
2189 } else
2190 return CompilerType(); // invalid argument type (empty)
2191 }
2192
2193 // TODO: Detect calling convention in DWARF?
2194 FunctionProtoType::ExtProtoInfo proto_info;
2195 proto_info.ExtInfo = cc;
2196 proto_info.Variadic = is_variadic;
2197 proto_info.ExceptionSpec = EST_None;
2198 proto_info.TypeQuals = clang::Qualifiers::fromFastMask(type_quals);
2199 proto_info.RefQualifier = RQ_None;
2200
2201 return GetType(getASTContext().getFunctionType(
2202 ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
2203}
2204
2205ParmVarDecl *TypeSystemClang::CreateParameterDeclaration(
2206 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
2207 const char *name, const CompilerType &param_type, int storage,
2208 bool add_decl) {
2209 ASTContext &ast = getASTContext();
2210 auto *decl = ParmVarDecl::CreateDeserialized(ast, 0);
2211 decl->setDeclContext(decl_ctx);
2212 if (name && name[0])
2213 decl->setDeclName(&ast.Idents.get(name));
2214 decl->setType(ClangUtil::GetQualType(param_type));
2215 decl->setStorageClass(static_cast<clang::StorageClass>(storage));
2216 SetOwningModule(decl, owning_module);
2217 if (add_decl)
2218 decl_ctx->addDecl(decl);
2219
2220 return decl;
2221}
2222
2223void TypeSystemClang::SetFunctionParameters(
2224 FunctionDecl *function_decl, llvm::ArrayRef<ParmVarDecl *> params) {
2225 if (function_decl)
2226 function_decl->setParams(params);
2227}
2228
2229CompilerType
2230TypeSystemClang::CreateBlockPointerType(const CompilerType &function_type) {
2231 QualType block_type = m_ast_up->getBlockPointerType(
2232 clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType()));
2233
2234 return GetType(block_type);
2235}
2236
2237#pragma mark Array Types
2238
2239CompilerType TypeSystemClang::CreateArrayType(const CompilerType &element_type,
2240 size_t element_count,
2241 bool is_vector) {
2242 if (element_type.IsValid()) {
2243 ASTContext &ast = getASTContext();
2244
2245 if (is_vector) {
2246 return GetType(ast.getExtVectorType(ClangUtil::GetQualType(element_type),
2247 element_count));
2248 } else {
2249
2250 llvm::APInt ap_element_count(64, element_count);
2251 if (element_count == 0) {
2252 return GetType(ast.getIncompleteArrayType(
2253 ClangUtil::GetQualType(element_type), clang::ArrayType::Normal, 0));
2254 } else {
2255 return GetType(ast.getConstantArrayType(
2256 ClangUtil::GetQualType(element_type), ap_element_count, nullptr,
2257 clang::ArrayType::Normal, 0));
2258 }
2259 }
2260 }
2261 return CompilerType();
2262}
2263
2264CompilerType TypeSystemClang::CreateStructForIdentifier(
2265 ConstString type_name,
2266 const std::initializer_list<std::pair<const char *, CompilerType>>
2267 &type_fields,
2268 bool packed) {
2269 CompilerType type;
2270 if (!type_name.IsEmpty() &&
2271 (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
2272 .IsValid()) {
2273 lldbassert(0 && "Trying to create a type for an existing name")lldb_private::lldb_assert(static_cast<bool>(0 &&
"Trying to create a type for an existing name"), "0 && \"Trying to create a type for an existing name\""
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, 2273)
;
2274 return type;
2275 }
2276
2277 type = CreateRecordType(nullptr, OptionalClangModuleID(), lldb::eAccessPublic,
2278 type_name.GetCString(), clang::TTK_Struct,
2279 lldb::eLanguageTypeC);
2280 StartTagDeclarationDefinition(type);
2281 for (const auto &field : type_fields)
2282 AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic,
2283 0);
2284 if (packed)
2285 SetIsPacked(type);
2286 CompleteTagDeclarationDefinition(type);
2287 return type;
2288}
2289
2290CompilerType TypeSystemClang::GetOrCreateStructForIdentifier(
2291 ConstString type_name,
2292 const std::initializer_list<std::pair<const char *, CompilerType>>
2293 &type_fields,
2294 bool packed) {
2295 CompilerType type;
2296 if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
2297 return type;
2298
2299 return CreateStructForIdentifier(type_name, type_fields, packed);
2300}
2301
2302#pragma mark Enumeration Types
2303
2304CompilerType TypeSystemClang::CreateEnumerationType(
2305 const char *name, clang::DeclContext *decl_ctx,
2306 OptionalClangModuleID owning_module, const Declaration &decl,
2307 const CompilerType &integer_clang_type, bool is_scoped) {
2308 // TODO: Do something intelligent with the Declaration object passed in
2309 // like maybe filling in the SourceLocation with it...
2310 ASTContext &ast = getASTContext();
2311
2312 // TODO: ask about these...
2313 // const bool IsFixed = false;
2314 EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0);
2315 enum_decl->setDeclContext(decl_ctx);
2316 if (name && name[0])
2317 enum_decl->setDeclName(&ast.Idents.get(name));
2318 enum_decl->setScoped(is_scoped);
2319 enum_decl->setScopedUsingClassTag(is_scoped);
2320 enum_decl->setFixed(false);
2321 SetOwningModule(enum_decl, owning_module);
2322 if (enum_decl) {
2323 if (decl_ctx)
2324 decl_ctx->addDecl(enum_decl);
2325
2326 // TODO: check if we should be setting the promotion type too?
2327 enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
2328
2329 enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
2330
2331 return GetType(ast.getTagDeclType(enum_decl));
2332 }
2333 return CompilerType();
2334}
2335
2336CompilerType TypeSystemClang::GetIntTypeFromBitSize(size_t bit_size,
2337 bool is_signed) {
2338 clang::ASTContext &ast = getASTContext();
2339
2340 if (is_signed) {
2341 if (bit_size == ast.getTypeSize(ast.SignedCharTy))
2342 return GetType(ast.SignedCharTy);
2343
2344 if (bit_size == ast.getTypeSize(ast.ShortTy))
2345 return GetType(ast.ShortTy);
2346
2347 if (bit_size == ast.getTypeSize(ast.IntTy))
2348 return GetType(ast.IntTy);
2349
2350 if (bit_size == ast.getTypeSize(ast.LongTy))
2351 return GetType(ast.LongTy);
2352
2353 if (bit_size == ast.getTypeSize(ast.LongLongTy))
2354 return GetType(ast.LongLongTy);
2355
2356 if (bit_size == ast.getTypeSize(ast.Int128Ty))
2357 return GetType(ast.Int128Ty);
2358 } else {
2359 if (bit_size == ast.getTypeSize(ast.UnsignedCharTy))
2360 return GetType(ast.UnsignedCharTy);
2361
2362 if (bit_size == ast.getTypeSize(ast.UnsignedShortTy))
2363 return GetType(ast.UnsignedShortTy);
2364
2365 if (bit_size == ast.getTypeSize(ast.UnsignedIntTy))
2366 return GetType(ast.UnsignedIntTy);
2367
2368 if (bit_size == ast.getTypeSize(ast.UnsignedLongTy))
2369 return GetType(ast.UnsignedLongTy);
2370
2371 if (bit_size == ast.getTypeSize(ast.UnsignedLongLongTy))
2372 return GetType(ast.UnsignedLongLongTy);
2373
2374 if (bit_size == ast.getTypeSize(ast.UnsignedInt128Ty))
2375 return GetType(ast.UnsignedInt128Ty);
2376 }
2377 return CompilerType();
2378}
2379
2380CompilerType TypeSystemClang::GetPointerSizedIntType(bool is_signed) {
2381 return GetIntTypeFromBitSize(
2382 getASTContext().getTypeSize(getASTContext().VoidPtrTy), is_signed);
2383}
2384
2385void TypeSystemClang::DumpDeclContextHiearchy(clang::DeclContext *decl_ctx) {
2386 if (decl_ctx) {
2387 DumpDeclContextHiearchy(decl_ctx->getParent());
2388
2389 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
2390 if (named_decl) {
2391 printf("%20s: %s\n", decl_ctx->getDeclKindName(),
2392 named_decl->getDeclName().getAsString().c_str());
2393 } else {
2394 printf("%20s\n", decl_ctx->getDeclKindName());
2395 }
2396 }
2397}
2398
2399void TypeSystemClang::DumpDeclHiearchy(clang::Decl *decl) {
2400 if (decl == nullptr)
2401 return;
2402 DumpDeclContextHiearchy(decl->getDeclContext());
2403
2404 clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
2405 if (record_decl) {
2406 printf("%20s: %s%s\n", decl->getDeclKindName(),
2407 record_decl->getDeclName().getAsString().c_str(),
2408 record_decl->isInjectedClassName() ? " (injected class name)" : "");
2409
2410 } else {
2411 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
2412 if (named_decl) {
2413 printf("%20s: %s\n", decl->getDeclKindName(),
2414 named_decl->getDeclName().getAsString().c_str());
2415 } else {
2416 printf("%20s\n", decl->getDeclKindName());
2417 }
2418 }
2419}
2420
2421bool TypeSystemClang::DeclsAreEquivalent(clang::Decl *lhs_decl,
2422 clang::Decl *rhs_decl) {
2423 if (lhs_decl && rhs_decl) {
2424 // Make sure the decl kinds match first
2425 const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
2426 const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
2427
2428 if (lhs_decl_kind == rhs_decl_kind) {
2429 // Now check that the decl contexts kinds are all equivalent before we
2430 // have to check any names of the decl contexts...
2431 clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
2432 clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
2433 if (lhs_decl_ctx && rhs_decl_ctx) {
2434 while (true) {
2435 if (lhs_decl_ctx && rhs_decl_ctx) {
2436 const clang::Decl::Kind lhs_decl_ctx_kind =
2437 lhs_decl_ctx->getDeclKind();
2438 const clang::Decl::Kind rhs_decl_ctx_kind =
2439 rhs_decl_ctx->getDeclKind();
2440 if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) {
2441 lhs_decl_ctx = lhs_decl_ctx->getParent();
2442 rhs_decl_ctx = rhs_decl_ctx->getParent();
2443
2444 if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr)
2445 break;
2446 } else
2447 return false;
2448 } else
2449 return false;
2450 }
2451
2452 // Now make sure the name of the decls match
2453 clang::NamedDecl *lhs_named_decl =
2454 llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
2455 clang::NamedDecl *rhs_named_decl =
2456 llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
2457 if (lhs_named_decl && rhs_named_decl) {
2458 clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2459 clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2460 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2461 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2462 return false;
2463 } else
2464 return false;
2465 } else
2466 return false;
2467
2468 // We know that the decl context kinds all match, so now we need to
2469 // make sure the names match as well
2470 lhs_decl_ctx = lhs_decl->getDeclContext();
2471 rhs_decl_ctx = rhs_decl->getDeclContext();
2472 while (true) {
2473 switch (lhs_decl_ctx->getDeclKind()) {
2474 case clang::Decl::TranslationUnit:
2475 // We don't care about the translation unit names
2476 return true;
2477 default: {
2478 clang::NamedDecl *lhs_named_decl =
2479 llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
2480 clang::NamedDecl *rhs_named_decl =
2481 llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
2482 if (lhs_named_decl && rhs_named_decl) {
2483 clang::DeclarationName lhs_decl_name =
2484 lhs_named_decl->getDeclName();
2485 clang::DeclarationName rhs_decl_name =
2486 rhs_named_decl->getDeclName();
2487 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2488 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2489 return false;
2490 } else
2491 return false;
2492 } else
2493 return false;
2494 } break;
2495 }
2496 lhs_decl_ctx = lhs_decl_ctx->getParent();
2497 rhs_decl_ctx = rhs_decl_ctx->getParent();
2498 }
2499 }
2500 }
2501 }
2502 return false;
2503}
2504bool TypeSystemClang::GetCompleteDecl(clang::ASTContext *ast,
2505 clang::Decl *decl) {
2506 if (!decl)
2507 return false;
2508
2509 ExternalASTSource *ast_source = ast->getExternalSource();
2510
2511 if (!ast_source)
2512 return false;
2513
2514 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
2515 if (tag_decl->isCompleteDefinition())
2516 return true;
2517
2518 if (!tag_decl->hasExternalLexicalStorage())
2519 return false;
2520
2521 ast_source->CompleteType(tag_decl);
2522
2523 return !tag_decl->getTypeForDecl()->isIncompleteType();
2524 } else if (clang::ObjCInterfaceDecl *objc_interface_decl =
2525 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) {
2526 if (objc_interface_decl->getDefinition())
2527 return true;
2528
2529 if (!objc_interface_decl->hasExternalLexicalStorage())
2530 return false;
2531
2532 ast_source->CompleteType(objc_interface_decl);
2533
2534 return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2535 } else {
2536 return false;
2537 }
2538}
2539
2540void TypeSystemClang::SetMetadataAsUserID(const clang::Decl *decl,
2541 user_id_t user_id) {
2542 ClangASTMetadata meta_data;
2543 meta_data.SetUserID(user_id);
2544 SetMetadata(decl, meta_data);
2545}
2546
2547void TypeSystemClang::SetMetadataAsUserID(const clang::Type *type,
2548 user_id_t user_id) {
2549 ClangASTMetadata meta_data;
2550 meta_data.SetUserID(user_id);
2551 SetMetadata(type, meta_data);
2552}
2553
2554void TypeSystemClang::SetMetadata(const clang::Decl *object,
2555 ClangASTMetadata &metadata) {
2556 m_decl_metadata[object] = metadata;
2557}
2558
2559void TypeSystemClang::SetMetadata(const clang::Type *object,
2560 ClangASTMetadata &metadata) {
2561 m_type_metadata[object] = metadata;
2562}
2563
2564ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Decl *object) {
2565 auto It = m_decl_metadata.find(object);
2566 if (It != m_decl_metadata.end())
2567 return &It->second;
2568 return nullptr;
2569}
2570
2571ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Type *object) {
2572 auto It = m_type_metadata.find(object);
2573 if (It != m_type_metadata.end())
2574 return &It->second;
2575 return nullptr;
2576}
2577
2578clang::DeclContext *
2579TypeSystemClang::GetDeclContextForType(const CompilerType &type) {
2580 return GetDeclContextForType(ClangUtil::GetQualType(type));
2581}
2582
2583/// Aggressively desugar the provided type, skipping past various kinds of
2584/// syntactic sugar and other constructs one typically wants to ignore.
2585/// The \p mask argument allows one to skip certain kinds of simplifications,
2586/// when one wishes to handle a certain kind of type directly.
2587static QualType
2588RemoveWrappingTypes(QualType type, ArrayRef<clang::Type::TypeClass> mask = {}) {
2589 while (true) {
2590 if (find(mask, type->getTypeClass()) != mask.end())
2591 return type;
2592 switch (type->getTypeClass()) {
2593 // This is not fully correct as _Atomic is more than sugar, but it is
2594 // sufficient for the purposes we care about.
2595 case clang::Type::Atomic:
2596 type = cast<clang::AtomicType>(type)->getValueType();
2597 break;
2598 case clang::Type::Auto:
2599 case clang::Type::Decltype:
2600 case clang::Type::Elaborated:
2601 case clang::Type::Paren:
2602 case clang::Type::SubstTemplateTypeParm:
2603 case clang::Type::TemplateSpecialization:
2604 case clang::Type::Typedef:
2605 case clang::Type::TypeOf:
2606 case clang::Type::TypeOfExpr:
2607 type = type->getLocallyUnqualifiedSingleStepDesugaredType();
2608 break;
2609 default:
2610 return type;
2611 }
2612 }
2613}
2614
2615clang::DeclContext *
2616TypeSystemClang::GetDeclContextForType(clang::QualType type) {
2617 if (type.isNull())
2618 return nullptr;
2619
2620 clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
2621 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2622 switch (type_class) {
2623 case clang::Type::ObjCInterface:
2624 return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
2625 ->getInterface();
2626 case clang::Type::ObjCObjectPointer:
2627 return GetDeclContextForType(
2628 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
2629 ->getPointeeType());
2630 case clang::Type::Record:
2631 return llvm::cast<clang::RecordType>(qual_type)->getDecl();
2632 case clang::Type::Enum:
2633 return llvm::cast<clang::EnumType>(qual_type)->getDecl();
2634 default:
2635 break;
2636 }
2637 // No DeclContext in this type...
2638 return nullptr;
2639}
2640
2641static bool GetCompleteQualType(clang::ASTContext *ast,
2642 clang::QualType qual_type,
2643 bool allow_completion = true) {
2644 qual_type = RemoveWrappingTypes(qual_type);
2645 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2646 switch (type_class) {
2647 case clang::Type::ConstantArray:
2648 case clang::Type::IncompleteArray:
2649 case clang::Type::VariableArray: {
2650 const clang::ArrayType *array_type =
2651 llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
2652
2653 if (array_type)
2654 return GetCompleteQualType(ast, array_type->getElementType(),
2655 allow_completion);
2656 } break;
2657 case clang::Type::Record: {
2658 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2659 if (cxx_record_decl) {
2660 if (cxx_record_decl->hasExternalLexicalStorage()) {
2661 const bool is_complete = cxx_record_decl->isCompleteDefinition();
2662 const bool fields_loaded =
2663 cxx_record_decl->hasLoadedFieldsFromExternalStorage();
2664 if (is_complete && fields_loaded)
2665 return true;
2666
2667 if (!allow_completion)
2668 return false;
2669
2670 // Call the field_begin() accessor to for it to use the external source
2671 // to load the fields...
2672 clang::ExternalASTSource *external_ast_source =
2673 ast->getExternalSource();
2674 if (external_ast_source) {
2675 external_ast_source->CompleteType(cxx_record_decl);
2676 if (cxx_record_decl->isCompleteDefinition()) {
2677 cxx_record_decl->field_begin();
2678 cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
2679 }
2680 }
2681 }
2682 }
2683 const clang::TagType *tag_type =
2684 llvm::cast<clang::TagType>(qual_type.getTypePtr());
2685 return !tag_type->isIncompleteType();
2686 } break;
2687
2688 case clang::Type::Enum: {
2689 const clang::TagType *tag_type =
2690 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
2691 if (tag_type) {
2692 clang::TagDecl *tag_decl = tag_type->getDecl();
2693 if (tag_decl) {
2694 if (tag_decl->getDefinition())
2695 return true;
2696
2697 if (!allow_completion)
2698 return false;
2699
2700 if (tag_decl->hasExternalLexicalStorage()) {
2701 if (ast) {
2702 clang::ExternalASTSource *external_ast_source =
2703 ast->getExternalSource();
2704 if (external_ast_source) {
2705 external_ast_source->CompleteType(tag_decl);
2706 return !tag_type->isIncompleteType();
2707 }
2708 }
2709 }
2710 return false;
2711 }
2712 }
2713
2714 } break;
2715 case clang::Type::ObjCObject:
2716 case clang::Type::ObjCInterface: {
2717 const clang::ObjCObjectType *objc_class_type =
2718 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
2719 if (objc_class_type) {
2720 clang::ObjCInterfaceDecl *class_interface_decl =
2721 objc_class_type->getInterface();
2722 // We currently can't complete objective C types through the newly added
2723 // ASTContext because it only supports TagDecl objects right now...
2724 if (class_interface_decl) {
2725 if (class_interface_decl->getDefinition())
2726 return true;
2727
2728 if (!allow_completion)
2729 return false;
2730
2731 if (class_interface_decl->hasExternalLexicalStorage()) {
2732 if (ast) {
2733 clang::ExternalASTSource *external_ast_source =
2734 ast->getExternalSource();
2735 if (external_ast_source) {
2736 external_ast_source->CompleteType(class_interface_decl);
2737 return !objc_class_type->isIncompleteType();
2738 }
2739 }
2740 }
2741 return false;
2742 }
2743 }
2744 } break;
2745
2746 case clang::Type::Attributed:
2747 return GetCompleteQualType(
2748 ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(),
2749 allow_completion);
2750
2751 default:
2752 break;
2753 }
2754
2755 return true;
2756}
2757
2758static clang::ObjCIvarDecl::AccessControl
2759ConvertAccessTypeToObjCIvarAccessControl(AccessType access) {
2760 switch (access) {
2761 case eAccessNone:
2762 return clang::ObjCIvarDecl::None;
2763 case eAccessPublic:
2764 return clang::ObjCIvarDecl::Public;
2765 case eAccessPrivate:
2766 return clang::ObjCIvarDecl::Private;
2767 case eAccessProtected:
2768 return clang::ObjCIvarDecl::Protected;
2769 case eAccessPackage:
2770 return clang::ObjCIvarDecl::Package;
2771 }
2772 return clang::ObjCIvarDecl::None;
2773}
2774
2775// Tests
2776
2777#ifndef NDEBUG1
2778bool TypeSystemClang::Verify(lldb::opaque_compiler_type_t type) {
2779 return !type || llvm::isa<clang::Type>(GetQualType(type).getTypePtr());
2780}
2781#endif
2782
2783bool TypeSystemClang::IsAggregateType(lldb::opaque_compiler_type_t type) {
2784 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
2785
2786 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2787 switch (type_class) {
2788 case clang::Type::IncompleteArray:
2789 case clang::Type::VariableArray:
2790 case clang::Type::ConstantArray:
2791 case clang::Type::ExtVector:
2792 case clang::Type::Vector:
2793 case clang::Type::Record:
2794 case clang::Type::ObjCObject:
2795 case clang::Type::ObjCInterface:
2796 return true;
2797 default:
2798 break;
2799 }
2800 // The clang type does have a value
2801 return false;
2802}
2803
2804bool TypeSystemClang::IsAnonymousType(lldb::opaque_compiler_type_t type) {
2805 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
2806
2807 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2808 switch (type_class) {
2809 case clang::Type::Record: {
2810 if (const clang::RecordType *record_type =
2811 llvm::dyn_cast_or_null<clang::RecordType>(
2812 qual_type.getTypePtrOrNull())) {
2813 if (const clang::RecordDecl *record_decl = record_type->getDecl()) {
2814 return record_decl->isAnonymousStructOrUnion();
2815 }
2816 }
2817 break;
2818 }
2819 default:
2820 break;
2821 }
2822 // The clang type does have a value
2823 return false;
2824}
2825
2826bool TypeSystemClang::IsArrayType(lldb::opaque_compiler_type_t type,
2827 CompilerType *element_type_ptr,
2828 uint64_t *size, bool *is_incomplete) {
2829 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
2830
2831 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2832 switch (type_class) {
2833 default:
2834 break;
2835
2836 case clang::Type::ConstantArray:
2837 if (element_type_ptr)
2838 element_type_ptr->SetCompilerType(
2839 this, llvm::cast<clang::ConstantArrayType>(qual_type)
2840 ->getElementType()
2841 .getAsOpaquePtr());
2842 if (size)
2843 *size = llvm::cast<clang::ConstantArrayType>(qual_type)
2844 ->getSize()
2845 .getLimitedValue(ULLONG_MAX(9223372036854775807LL*2ULL+1ULL));
2846 if (is_incomplete)
2847 *is_incomplete = false;
2848 return true;
2849
2850 case clang::Type::IncompleteArray:
2851 if (element_type_ptr)
2852 element_type_ptr->SetCompilerType(
2853 this, llvm::cast<clang::IncompleteArrayType>(qual_type)
2854 ->getElementType()
2855 .getAsOpaquePtr());
2856 if (size)
2857 *size = 0;
2858 if (is_incomplete)
2859 *is_incomplete = true;
2860 return true;
2861
2862 case clang::Type::VariableArray:
2863 if (element_type_ptr)
2864 element_type_ptr->SetCompilerType(
2865 this, llvm::cast<clang::VariableArrayType>(qual_type)
2866 ->getElementType()
2867 .getAsOpaquePtr());
2868 if (size)
2869 *size = 0;
2870 if (is_incomplete)
2871 *is_incomplete = false;
2872 return true;
2873
2874 case clang::Type::DependentSizedArray:
2875 if (element_type_ptr)
2876 element_type_ptr->SetCompilerType(
2877 this, llvm::cast<clang::DependentSizedArrayType>(qual_type)
2878 ->getElementType()
2879 .getAsOpaquePtr());
2880 if (size)
2881 *size = 0;
2882 if (is_incomplete)
2883 *is_incomplete = false;
2884 return true;
2885 }
2886 if (element_type_ptr)
2887 element_type_ptr->Clear();
2888 if (size)
2889 *size = 0;
2890 if (is_incomplete)
2891 *is_incomplete = false;
2892 return false;
2893}
2894
2895bool TypeSystemClang::IsVectorType(lldb::opaque_compiler_type_t type,
2896 CompilerType *element_type, uint64_t *size) {
2897 clang::QualType qual_type(GetCanonicalQualType(type));
2898
2899 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2900 switch (type_class) {
2901 case clang::Type::Vector: {
2902 const clang::VectorType *vector_type =
2903 qual_type->getAs<clang::VectorType>();
2904 if (vector_type) {
2905 if (size)
2906 *size = vector_type->getNumElements();
2907 if (element_type)
2908 *element_type = GetType(vector_type->getElementType());
2909 }
2910 return true;
2911 } break;
2912 case clang::Type::ExtVector: {
2913 const clang::ExtVectorType *ext_vector_type =
2914 qual_type->getAs<clang::ExtVectorType>();
2915 if (ext_vector_type) {
2916 if (size)
2917 *size = ext_vector_type->getNumElements();
2918 if (element_type)
2919 *element_type =
2920 CompilerType(this, ext_vector_type->getElementType().getAsOpaquePtr());
2921 }
2922 return true;
2923 }
2924 default:
2925 break;
2926 }
2927 return false;
2928}
2929
2930bool TypeSystemClang::IsRuntimeGeneratedType(
2931 lldb::opaque_compiler_type_t type) {
2932 clang::DeclContext *decl_ctx = GetDeclContextForType(GetQualType(type));
2933 if (!decl_ctx)
2934 return false;
2935
2936 if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
2937 return false;
2938
2939 clang::ObjCInterfaceDecl *result_iface_decl =
2940 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
2941
2942 ClangASTMetadata *ast_metadata = GetMetadata(result_iface_decl);
2943 if (!ast_metadata)
2944 return false;
2945 return (ast_metadata->GetISAPtr() != 0);
2946}
2947
2948bool TypeSystemClang::IsCharType(lldb::opaque_compiler_type_t type) {
2949 return GetQualType(type).getUnqualifiedType()->isCharType();
2950}
2951
2952bool TypeSystemClang::IsCompleteType(lldb::opaque_compiler_type_t type) {
2953 const bool allow_completion = false;
2954 return GetCompleteQualType(&getASTContext(), GetQualType(type),
2955 allow_completion);
2956}
2957
2958bool TypeSystemClang::IsConst(lldb::opaque_compiler_type_t type) {
2959 return GetQualType(type).isConstQualified();
2960}
2961
2962bool TypeSystemClang::IsCStringType(lldb::opaque_compiler_type_t type,
2963 uint32_t &length) {
2964 CompilerType pointee_or_element_clang_type;
2965 length = 0;
2966 Flags type_flags(GetTypeInfo(type, &pointee_or_element_clang_type));
2967
2968 if (!pointee_or_element_clang_type.IsValid())
2969 return false;
2970
2971 if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) {
2972 if (pointee_or_element_clang_type.IsCharType()) {
2973 if (type_flags.Test(eTypeIsArray)) {
2974 // We know the size of the array and it could be a C string since it is
2975 // an array of characters
2976 length = llvm::cast<clang::ConstantArrayType>(
2977 GetCanonicalQualType(type).getTypePtr())
2978 ->getSize()
2979 .getLimitedValue();
2980 }
2981 return true;
2982 }
2983 }
2984 return false;
2985}
2986
2987bool TypeSystemClang::IsFunctionType(lldb::opaque_compiler_type_t type) {
2988 if (type) {
2989 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
2990
2991 if (qual_type->isFunctionType()) {
2992 return true;
2993 }
2994
2995 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2996 switch (type_class) {
2997 default:
2998 break;
2999 case clang::Type::LValueReference:
3000 case clang::Type::RValueReference: {
3001 const clang::ReferenceType *reference_type =
3002 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3003 if (reference_type)
3004 return IsFunctionType(
3005 reference_type->getPointeeType().getAsOpaquePtr());
3006 } break;
3007 }
3008 }
3009 return false;
3010}
3011
3012// Used to detect "Homogeneous Floating-point Aggregates"
3013uint32_t
3014TypeSystemClang::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
3015 CompilerType *base_type_ptr) {
3016 if (!type)
3017 return 0;
3018
3019 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
3020 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3021 switch (type_class) {
3022 case clang::Type::Record:
3023 if (GetCompleteType(type)) {
3024 const clang::CXXRecordDecl *cxx_record_decl =
3025 qual_type->getAsCXXRecordDecl();
3026 if (cxx_record_decl) {
3027 if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass())
3028 return 0;
3029 }
3030 const clang::RecordType *record_type =
3031 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3032 if (record_type) {
3033 const clang::RecordDecl *record_decl = record_type->getDecl();
3034 if (record_decl) {
3035 // We are looking for a structure that contains only floating point
3036 // types
3037 clang::RecordDecl::field_iterator field_pos,
3038 field_end = record_decl->field_end();
3039 uint32_t num_fields = 0;
3040 bool is_hva = false;
3041 bool is_hfa = false;
3042 clang::QualType base_qual_type;
3043 uint64_t base_bitwidth = 0;
3044 for (field_pos = record_decl->field_begin(); field_pos != field_end;
3045 ++field_pos) {
3046 clang::QualType field_qual_type = field_pos->getType();
3047 uint64_t field_bitwidth = getASTContext().getTypeSize(qual_type);
3048 if (field_qual_type->isFloatingType()) {
3049 if (field_qual_type->isComplexType())
3050 return 0;
3051 else {
3052 if (num_fields == 0)
3053 base_qual_type = field_qual_type;
3054 else {
3055 if (is_hva)
3056 return 0;
3057 is_hfa = true;
3058 if (field_qual_type.getTypePtr() !=
3059 base_qual_type.getTypePtr())
3060 return 0;
3061 }
3062 }
3063 } else if (field_qual_type->isVectorType() ||
3064 field_qual_type->isExtVectorType()) {
3065 if (num_fields == 0) {
3066 base_qual_type = field_qual_type;
3067 base_bitwidth = field_bitwidth;
3068 } else {
3069 if (is_hfa)
3070 return 0;
3071 is_hva = true;
3072 if (base_bitwidth != field_bitwidth)
3073 return 0;
3074 if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3075 return 0;
3076 }
3077 } else
3078 return 0;
3079 ++num_fields;
3080 }
3081 if (base_type_ptr)
3082 *base_type_ptr = CompilerType(this, base_qual_type.getAsOpaquePtr());
3083 return num_fields;
3084 }
3085 }
3086 }
3087 break;
3088
3089 default:
3090 break;
3091 }
3092 return 0;
3093}
3094
3095size_t TypeSystemClang::GetNumberOfFunctionArguments(
3096 lldb::opaque_compiler_type_t type) {
3097 if (type) {
3098 clang::QualType qual_type(GetCanonicalQualType(type));
3099 const clang::FunctionProtoType *func =
3100 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3101 if (func)
3102 return func->getNumParams();
3103 }
3104 return 0;
3105}
3106
3107CompilerType
3108TypeSystemClang::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
3109 const size_t index) {
3110 if (type) {
3111 clang::QualType qual_type(GetQualType(type));
3112 const clang::FunctionProtoType *func =
3113 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3114 if (func) {
3115 if (index < func->getNumParams())
3116 return CompilerType(this, func->getParamType(index).getAsOpaquePtr());
3117 }
3118 }
3119 return CompilerType();
3120}
3121
3122bool TypeSystemClang::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
3123 if (type) {
3124 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3125
3126 if (qual_type->isFunctionPointerType())
3127 return true;
3128
3129 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3130 switch (type_class) {
3131 default:
3132 break;
3133
3134 case clang::Type::LValueReference:
3135 case clang::Type::RValueReference: {
3136 const clang::ReferenceType *reference_type =
3137 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3138 if (reference_type)
3139 return IsFunctionPointerType(
3140 reference_type->getPointeeType().getAsOpaquePtr());
3141 } break;
3142 }
3143 }
3144 return false;
3145}
3146
3147bool TypeSystemClang::IsBlockPointerType(
3148 lldb::opaque_compiler_type_t type,
3149 CompilerType *function_pointer_type_ptr) {
3150 if (type) {
3151 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3152
3153 if (qual_type->isBlockPointerType()) {
3154 if (function_pointer_type_ptr) {
3155 const clang::BlockPointerType *block_pointer_type =
3156 qual_type->getAs<clang::BlockPointerType>();
3157 QualType pointee_type = block_pointer_type->getPointeeType();
3158 QualType function_pointer_type = m_ast_up->getPointerType(pointee_type);
3159 *function_pointer_type_ptr =
3160 CompilerType(this, function_pointer_type.getAsOpaquePtr());
3161 }
3162 return true;
3163 }
3164
3165 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3166 switch (type_class) {
3167 default:
3168 break;
3169
3170 case clang::Type::LValueReference:
3171 case clang::Type::RValueReference: {
3172 const clang::ReferenceType *reference_type =
3173 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3174 if (reference_type)
3175 return IsBlockPointerType(
3176 reference_type->getPointeeType().getAsOpaquePtr(),
3177 function_pointer_type_ptr);
3178 } break;
3179 }
3180 }
3181 return false;
3182}
3183
3184bool TypeSystemClang::IsIntegerType(lldb::opaque_compiler_type_t type,
3185 bool &is_signed) {
3186 if (!type)
3187 return false;
3188
3189 clang::QualType qual_type(GetCanonicalQualType(type));
3190 const clang::BuiltinType *builtin_type =
3191 llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3192
3193 if (builtin_type) {
3194 if (builtin_type->isInteger()) {
3195 is_signed = builtin_type->isSignedInteger();
3196 return true;
3197 }
3198 }
3199
3200 return false;
3201}
3202
3203bool TypeSystemClang::IsEnumerationType(lldb::opaque_compiler_type_t type,
3204 bool &is_signed) {
3205 if (type) {
3206 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3207 GetCanonicalQualType(type)->getCanonicalTypeInternal());
3208
3209 if (enum_type) {
3210 IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
3211 is_signed);
3212 return true;
3213 }
3214 }
3215
3216 return false;
3217}
3218
3219bool TypeSystemClang::IsScopedEnumerationType(
3220 lldb::opaque_compiler_type_t type) {
3221 if (type) {
3222 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3223 GetCanonicalQualType(type)->getCanonicalTypeInternal());
3224
3225 if (enum_type) {
3226 return enum_type->isScopedEnumeralType();
3227 }
3228 }
3229
3230 return false;
3231}
3232
3233bool TypeSystemClang::IsPointerType(lldb::opaque_compiler_type_t type,
3234 CompilerType *pointee_type) {
3235 if (type) {
3236 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3237 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3238 switch (type_class) {
3239 case clang::Type::Builtin:
3240 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3241 default:
3242 break;
3243 case clang::BuiltinType::ObjCId:
3244 case clang::BuiltinType::ObjCClass:
3245 return true;
3246 }
3247 return false;
3248 case clang::Type::ObjCObjectPointer:
3249 if (pointee_type)
3250 pointee_type->SetCompilerType(
3251 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3252 ->getPointeeType()
3253 .getAsOpaquePtr());
3254 return true;
3255 case clang::Type::BlockPointer:
3256 if (pointee_type)
3257 pointee_type->SetCompilerType(
3258 this, llvm::cast<clang::BlockPointerType>(qual_type)
3259 ->getPointeeType()
3260 .getAsOpaquePtr());
3261 return true;
3262 case clang::Type::Pointer:
3263 if (pointee_type)
3264 pointee_type->SetCompilerType(this,
3265 llvm::cast<clang::PointerType>(qual_type)
3266 ->getPointeeType()
3267 .getAsOpaquePtr());
3268 return true;
3269 case clang::Type::MemberPointer:
3270 if (pointee_type)
3271 pointee_type->SetCompilerType(
3272 this, llvm::cast<clang::MemberPointerType>(qual_type)
3273 ->getPointeeType()
3274 .getAsOpaquePtr());
3275 return true;
3276 default:
3277 break;
3278 }
3279 }
3280 if (pointee_type)
3281 pointee_type->Clear();
3282 return false;
3283}
3284
3285bool TypeSystemClang::IsPointerOrReferenceType(
3286 lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
3287 if (type) {
3288 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3289 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3290 switch (type_class) {
3291 case clang::Type::Builtin:
3292 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3293 default:
3294 break;
3295 case clang::BuiltinType::ObjCId:
3296 case clang::BuiltinType::ObjCClass:
3297 return true;
3298 }
3299 return false;
3300 case clang::Type::ObjCObjectPointer:
3301 if (pointee_type)
3302 pointee_type->SetCompilerType(
3303 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3304 ->getPointeeType().getAsOpaquePtr());
3305 return true;
3306 case clang::Type::BlockPointer:
3307 if (pointee_type)
3308 pointee_type->SetCompilerType(
3309 this, llvm::cast<clang::BlockPointerType>(qual_type)
3310 ->getPointeeType()
3311 .getAsOpaquePtr());
3312 return true;
3313 case clang::Type::Pointer:
3314 if (pointee_type)
3315 pointee_type->SetCompilerType(this,
3316 llvm::cast<clang::PointerType>(qual_type)
3317 ->getPointeeType()
3318 .getAsOpaquePtr());
3319 return true;
3320 case clang::Type::MemberPointer:
3321 if (pointee_type)
3322 pointee_type->SetCompilerType(
3323 this, llvm::cast<clang::MemberPointerType>(qual_type)
3324 ->getPointeeType()
3325 .getAsOpaquePtr());
3326 return true;
3327 case clang::Type::LValueReference:
3328 if (pointee_type)
3329 pointee_type->SetCompilerType(
3330 this, llvm::cast<clang::LValueReferenceType>(qual_type)
3331 ->desugar()
3332 .getAsOpaquePtr());
3333 return true;
3334 case clang::Type::RValueReference:
3335 if (pointee_type)
3336 pointee_type->SetCompilerType(
3337 this, llvm::cast<clang::RValueReferenceType>(qual_type)
3338 ->desugar()
3339 .getAsOpaquePtr());
3340 return true;
3341 default:
3342 break;
3343 }
3344 }
3345 if (pointee_type)
3346 pointee_type->Clear();
3347 return false;
3348}
3349
3350bool TypeSystemClang::IsReferenceType(lldb::opaque_compiler_type_t type,
3351 CompilerType *pointee_type,
3352 bool *is_rvalue) {
3353 if (type) {
3354 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3355 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3356
3357 switch (type_class) {
3358 case clang::Type::LValueReference:
3359 if (pointee_type)
3360 pointee_type->SetCompilerType(
3361 this, llvm::cast<clang::LValueReferenceType>(qual_type)
3362 ->desugar()
3363 .getAsOpaquePtr());
3364 if (is_rvalue)
3365 *is_rvalue = false;
3366 return true;
3367 case clang::Type::RValueReference:
3368 if (pointee_type)
3369 pointee_type->SetCompilerType(
3370 this, llvm::cast<clang::RValueReferenceType>(qual_type)
3371 ->desugar()
3372 .getAsOpaquePtr());
3373 if (is_rvalue)
3374 *is_rvalue = true;
3375 return true;
3376
3377 default:
3378 break;
3379 }
3380 }
3381 if (pointee_type)
3382 pointee_type->Clear();
3383 return false;
3384}
3385
3386bool TypeSystemClang::IsFloatingPointType(lldb::opaque_compiler_type_t type,
3387 uint32_t &count, bool &is_complex) {
3388 if (type) {
3389 clang::QualType qual_type(GetCanonicalQualType(type));
3390
3391 if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
3392 qual_type->getCanonicalTypeInternal())) {
3393 clang::BuiltinType::Kind kind = BT->getKind();
3394 if (kind >= clang::BuiltinType::Float &&
3395 kind <= clang::BuiltinType::LongDouble) {
3396 count = 1;
3397 is_complex = false;
3398 return true;
3399 }
3400 } else if (const clang::ComplexType *CT =
3401 llvm::dyn_cast<clang::ComplexType>(
3402 qual_type->getCanonicalTypeInternal())) {
3403 if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count,
3404 is_complex)) {
3405 count = 2;
3406 is_complex = true;
3407 return true;
3408 }
3409 } else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(
3410 qual_type->getCanonicalTypeInternal())) {
3411 if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count,
3412 is_complex)) {
3413 count = VT->getNumElements();
3414 is_complex = false;
3415 return true;
3416 }
3417 }
3418 }
3419 count = 0;
3420 is_complex = false;
3421 return false;
3422}
3423
3424bool TypeSystemClang::IsDefined(lldb::opaque_compiler_type_t type) {
3425 if (!type)
3426 return false;
3427
3428 clang::QualType qual_type(GetQualType(type));
3429 const clang::TagType *tag_type =
3430 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
3431 if (tag_type) {
3432 clang::TagDecl *tag_decl = tag_type->getDecl();
3433 if (tag_decl)
3434 return tag_decl->isCompleteDefinition();
3435 return false;
3436 } else {
3437 const clang::ObjCObjectType *objc_class_type =
3438 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3439 if (objc_class_type) {
3440 clang::ObjCInterfaceDecl *class_interface_decl =
3441 objc_class_type->getInterface();
3442 if (class_interface_decl)
3443 return class_interface_decl->getDefinition() != nullptr;
3444 return false;
3445 }
3446 }
3447 return true;
3448}
3449
3450bool TypeSystemClang::IsObjCClassType(const CompilerType &type) {
3451 if (ClangUtil::IsClangType(type)) {
3452 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3453
3454 const clang::ObjCObjectPointerType *obj_pointer_type =
3455 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3456
3457 if (obj_pointer_type)
3458 return obj_pointer_type->isObjCClassType();
3459 }
3460 return false;
3461}
3462
3463bool TypeSystemClang::IsObjCObjectOrInterfaceType(const CompilerType &type) {
3464 if (ClangUtil::IsClangType(type))
3465 return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
3466 return false;
3467}
3468
3469bool TypeSystemClang::IsClassType(lldb::opaque_compiler_type_t type) {
3470 if (!type)
3471 return false;
3472 clang::QualType qual_type(GetCanonicalQualType(type));
3473 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3474 return (type_class == clang::Type::Record);
3475}
3476
3477bool TypeSystemClang::IsEnumType(lldb::opaque_compiler_type_t type) {
3478 if (!type)
3479 return false;
3480 clang::QualType qual_type(GetCanonicalQualType(type));
3481 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3482 return (type_class == clang::Type::Enum);
3483}
3484
3485bool TypeSystemClang::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
3486 if (type) {
3487 clang::QualType qual_type(GetCanonicalQualType(type));
3488 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3489 switch (type_class) {
3490 case clang::Type::Record:
3491 if (GetCompleteType(type)) {
3492 const clang::RecordType *record_type =
3493 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3494 const clang::RecordDecl *record_decl = record_type->getDecl();
3495 if (record_decl) {
3496 const clang::CXXRecordDecl *cxx_record_decl =
3497 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3498 if (cxx_record_decl)
3499 return cxx_record_decl->isPolymorphic();
3500 }
3501 }
3502 break;
3503
3504 default:
3505 break;
3506 }
3507 }
3508 return false;
3509}
3510
3511bool TypeSystemClang::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
3512 CompilerType *dynamic_pointee_type,
3513 bool check_cplusplus,
3514 bool check_objc) {
3515 clang::QualType pointee_qual_type;
3516 if (type) {
3517 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3518 bool success = false;
3519 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3520 switch (type_class) {
3521 case clang::Type::Builtin:
3522 if (check_objc &&
3523 llvm::cast<clang::BuiltinType>(qual_type)->getKind() ==
3524 clang::BuiltinType::ObjCId) {
3525 if (dynamic_pointee_type)
3526 dynamic_pointee_type->SetCompilerType(this, type);
3527 return true;
3528 }
3529 break;
3530
3531 case clang::Type::ObjCObjectPointer:
3532 if (check_objc) {
3533 if (const auto *objc_pointee_type =
3534 qual_type->getPointeeType().getTypePtrOrNull()) {
3535 if (const auto *objc_object_type =
3536 llvm::dyn_cast_or_null<clang::ObjCObjectType>(
3537 objc_pointee_type)) {
3538 if (objc_object_type->isObjCClass())
3539 return false;
3540 }
3541 }
3542 if (dynamic_pointee_type)
3543 dynamic_pointee_type->SetCompilerType(
3544 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3545 ->getPointeeType()
3546 .getAsOpaquePtr());
3547 return true;
3548 }
3549 break;
3550
3551 case clang::Type::Pointer:
3552 pointee_qual_type =
3553 llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
3554 success = true;
3555 break;
3556
3557 case clang::Type::LValueReference:
3558 case clang::Type::RValueReference:
3559 pointee_qual_type =
3560 llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
3561 success = true;
3562 break;
3563
3564 default:
3565 break;
3566 }
3567
3568 if (success) {
3569 // Check to make sure what we are pointing too is a possible dynamic C++
3570 // type We currently accept any "void *" (in case we have a class that
3571 // has been watered down to an opaque pointer) and virtual C++ classes.
3572 const clang::Type::TypeClass pointee_type_class =
3573 pointee_qual_type.getCanonicalType()->getTypeClass();
3574 switch (pointee_type_class) {
3575 case clang::Type::Builtin:
3576 switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) {
3577 case clang::BuiltinType::UnknownAny:
3578 case clang::BuiltinType::Void:
3579 if (dynamic_pointee_type)
3580 dynamic_pointee_type->SetCompilerType(
3581 this, pointee_qual_type.getAsOpaquePtr());
3582 return true;
3583 default:
3584 break;
3585 }
3586 break;
3587
3588 case clang::Type::Record:
3589 if (check_cplusplus) {
3590 clang::CXXRecordDecl *cxx_record_decl =
3591 pointee_qual_type->getAsCXXRecordDecl();
3592 if (cxx_record_decl) {
3593 bool is_complete = cxx_record_decl->isCompleteDefinition();
3594
3595 if (is_complete)
3596 success = cxx_record_decl->isDynamicClass();
3597 else {
3598 ClangASTMetadata *metadata = GetMetadata(cxx_record_decl);
3599 if (metadata)
3600 success = metadata->GetIsDynamicCXXType();
3601 else {
3602 is_complete = GetType(pointee_qual_type).GetCompleteType();
3603 if (is_complete)
3604 success = cxx_record_decl->isDynamicClass();
3605 else
3606 success = false;
3607 }
3608 }
3609
3610 if (success) {
3611 if (dynamic_pointee_type)
3612 dynamic_pointee_type->SetCompilerType(
3613 this, pointee_qual_type.getAsOpaquePtr());
3614 return true;
3615 }
3616 }
3617 }
3618 break;
3619
3620 case clang::Type::ObjCObject:
3621 case clang::Type::ObjCInterface:
3622 if (check_objc) {
3623 if (dynamic_pointee_type)
3624 dynamic_pointee_type->SetCompilerType(
3625 this, pointee_qual_type.getAsOpaquePtr());
3626 return true;
3627 }
3628 break;
3629
3630 default:
3631 break;
3632 }
3633 }
3634 }
3635 if (dynamic_pointee_type)
3636 dynamic_pointee_type->Clear();
3637 return false;
3638}
3639
3640bool TypeSystemClang::IsScalarType(lldb::opaque_compiler_type_t type) {
3641 if (!type)
3642 return false;
3643
3644 return (GetTypeInfo(type, nullptr) & eTypeIsScalar) != 0;
3645}
3646
3647bool TypeSystemClang::IsTypedefType(lldb::opaque_compiler_type_t type) {
3648 if (!type)
3649 return false;
3650 return RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef})
3651 ->getTypeClass() == clang::Type::Typedef;
3652}
3653
3654bool TypeSystemClang::IsVoidType(lldb::opaque_compiler_type_t type) {
3655 if (!type)
3656 return false;
3657 return GetCanonicalQualType(type)->isVoidType();
3658}
3659
3660bool TypeSystemClang::CanPassInRegisters(const CompilerType &type) {
3661 if (auto *record_decl =
3662 TypeSystemClang::GetAsRecordDecl(type)) {
3663 return record_decl->canPassInRegisters();
3664 }
3665 return false;
3666}
3667
3668bool TypeSystemClang::SupportsLanguage(lldb::LanguageType language) {
3669 return TypeSystemClangSupportsLanguage(language);
3670}
3671
3672Optional<std::string>
3673TypeSystemClang::GetCXXClassName(const CompilerType &type) {
3674 if (!type)
3675 return llvm::None;
3676
3677 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3678 if (qual_type.isNull())
3679 return llvm::None;
3680
3681 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3682 if (!cxx_record_decl)
3683 return llvm::None;
3684
3685 return std::string(cxx_record_decl->getIdentifier()->getNameStart());
3686}
3687
3688bool TypeSystemClang::IsCXXClassType(const CompilerType &type) {
3689 if (!type)
3690 return false;
3691
3692 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3693 return !qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr;
3694}
3695
3696bool TypeSystemClang::IsBeingDefined(lldb::opaque_compiler_type_t type) {
3697 if (!type)
3698 return false;
3699 clang::QualType qual_type(GetCanonicalQualType(type));
3700 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
3701 if (tag_type)
3702 return tag_type->isBeingDefined();
3703 return false;
3704}
3705
3706bool TypeSystemClang::IsObjCObjectPointerType(const CompilerType &type,
3707 CompilerType *class_type_ptr) {
3708 if (!ClangUtil::IsClangType(type))
3709 return false;
3710
3711 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3712
3713 if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) {
3714 if (class_type_ptr) {
3715 if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) {
3716 const clang::ObjCObjectPointerType *obj_pointer_type =
3717 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3718 if (obj_pointer_type == nullptr)
3719 class_type_ptr->Clear();
3720 else
3721 class_type_ptr->SetCompilerType(
3722 type.GetTypeSystem(),
3723 clang::QualType(obj_pointer_type->getInterfaceType(), 0)
3724 .getAsOpaquePtr());
3725 }
3726 }
3727 return true;
3728 }
3729 if (class_type_ptr)
3730 class_type_ptr->Clear();
3731 return false;
3732}
3733
3734// Type Completion
3735
3736bool TypeSystemClang::GetCompleteType(lldb::opaque_compiler_type_t type) {
3737 if (!type)
3738 return false;
3739 const bool allow_completion = true;
3740 return GetCompleteQualType(&getASTContext(), GetQualType(type),
3741 allow_completion);
3742}
3743
3744ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type) {
3745 if (!type)
3746 return ConstString();
3747
3748 clang::QualType qual_type(GetQualType(type));
3749
3750 // Remove certain type sugar from the name. Sugar such as elaborated types
3751 // or template types which only serve to improve diagnostics shouldn't
3752 // act as their own types from the user's perspective (e.g., formatter
3753 // shouldn't format a variable differently depending on how the ser has
3754 // specified the type. '::Type' and 'Type' should behave the same).
3755 // Typedefs and atomic derived types are not removed as they are actually
3756 // useful for identifiying specific types.
3757 qual_type = RemoveWrappingTypes(qual_type,
3758 {clang::Type::Typedef, clang::Type::Atomic});
3759
3760 // For a typedef just return the qualified name.
3761 if (const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
3762 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
3763 return ConstString(GetTypeNameForDecl(typedef_decl));
3764 }
3765
3766 return ConstString(qual_type.getAsString(GetTypePrintingPolicy()));
3767}
3768
3769ConstString
3770TypeSystemClang::GetDisplayTypeName(lldb::opaque_compiler_type_t type) {
3771 if (!type)
3772 return ConstString();
3773
3774 clang::QualType qual_type(GetQualType(type));
3775 clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
3776 printing_policy.SuppressTagKeyword = true;
3777 printing_policy.SuppressScope = false;
3778 printing_policy.SuppressUnwrittenScope = true;
3779 printing_policy.SuppressInlineNamespace = true;
3780 return ConstString(qual_type.getAsString(printing_policy));
3781}
3782
3783uint32_t
3784TypeSystemClang::GetTypeInfo(lldb::opaque_compiler_type_t type,
3785 CompilerType *pointee_or_element_clang_type) {
3786 if (!type)
3787 return 0;
3788
3789 if (pointee_or_element_clang_type)
3790 pointee_or_element_clang_type->Clear();
3791
3792 clang::QualType qual_type =
3793 RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
3794
3795 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3796 switch (type_class) {
3797 case clang::Type::Attributed:
3798 return GetTypeInfo(
3799 qual_type->getAs<clang::AttributedType>()
3800 ->getModifiedType().getAsOpaquePtr(),
3801 pointee_or_element_clang_type);
3802 case clang::Type::Builtin: {
3803 const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(
3804 qual_type->getCanonicalTypeInternal());
3805
3806 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
3807 switch (builtin_type->getKind()) {
3808 case clang::BuiltinType::ObjCId:
3809 case clang::BuiltinType::ObjCClass:
3810 if (pointee_or_element_clang_type)
3811 pointee_or_element_clang_type->SetCompilerType(
3812 this, getASTContext().ObjCBuiltinClassTy.getAsOpaquePtr());
3813 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3814 break;
3815
3816 case clang::BuiltinType::ObjCSel:
3817 if (pointee_or_element_clang_type)
3818 pointee_or_element_clang_type->SetCompilerType(
3819 this, getASTContext().CharTy.getAsOpaquePtr());
3820 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3821 break;
3822
3823 case clang::BuiltinType::Bool:
3824 case clang::BuiltinType::Char_U:
3825 case clang::BuiltinType::UChar:
3826 case clang::BuiltinType::WChar_U:
3827 case clang::BuiltinType::Char16:
3828 case clang::BuiltinType::Char32:
3829 case clang::BuiltinType::UShort:
3830 case clang::BuiltinType::UInt:
3831 case clang::BuiltinType::ULong:
3832 case clang::BuiltinType::ULongLong:
3833 case clang::BuiltinType::UInt128:
3834 case clang::BuiltinType::Char_S:
3835 case clang::BuiltinType::SChar:
3836 case clang::BuiltinType::WChar_S:
3837 case clang::BuiltinType::Short:
3838 case clang::BuiltinType::Int:
3839 case clang::BuiltinType::Long:
3840 case clang::BuiltinType::LongLong:
3841 case clang::BuiltinType::Int128:
3842 case clang::BuiltinType::Float:
3843 case clang::BuiltinType::Double:
3844 case clang::BuiltinType::LongDouble:
3845 builtin_type_flags |= eTypeIsScalar;
3846 if (builtin_type->isInteger()) {
3847 builtin_type_flags |= eTypeIsInteger;
3848 if (builtin_type->isSignedInteger())
3849 builtin_type_flags |= eTypeIsSigned;
3850 } else if (builtin_type->isFloatingPoint())
3851 builtin_type_flags |= eTypeIsFloat;
3852 break;
3853 default:
3854 break;
3855 }
3856 return builtin_type_flags;
3857 }
3858
3859 case clang::Type::BlockPointer:
3860 if (pointee_or_element_clang_type)
3861 pointee_or_element_clang_type->SetCompilerType(
3862 this, qual_type->getPointeeType().getAsOpaquePtr());
3863 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
3864
3865 case clang::Type::Complex: {
3866 uint32_t complex_type_flags =
3867 eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
3868 const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(
3869 qual_type->getCanonicalTypeInternal());
3870 if (complex_type) {
3871 clang::QualType complex_element_type(complex_type->getElementType());
3872 if (complex_element_type->isIntegerType())
3873 complex_type_flags |= eTypeIsFloat;
3874 else if (complex_element_type->isFloatingType())
3875 complex_type_flags |= eTypeIsInteger;
3876 }
3877 return complex_type_flags;
3878 } break;
3879
3880 case clang::Type::ConstantArray:
3881 case clang::Type::DependentSizedArray:
3882 case clang::Type::IncompleteArray:
3883 case clang::Type::VariableArray:
3884 if (pointee_or_element_clang_type)
3885 pointee_or_element_clang_type->SetCompilerType(
3886 this, llvm::cast<clang::ArrayType>(qual_type.getTypePtr())
3887 ->getElementType()
3888 .getAsOpaquePtr());
3889 return eTypeHasChildren | eTypeIsArray;
3890
3891 case clang::Type::DependentName:
3892 return 0;
3893 case clang::Type::DependentSizedExtVector:
3894 return eTypeHasChildren | eTypeIsVector;
3895 case clang::Type::DependentTemplateSpecialization:
3896 return eTypeIsTemplate;
3897
3898 case clang::Type::Enum:
3899 if (pointee_or_element_clang_type)
3900 pointee_or_element_clang_type->SetCompilerType(
3901 this, llvm::cast<clang::EnumType>(qual_type)
3902 ->getDecl()
3903 ->getIntegerType()
3904 .getAsOpaquePtr());
3905 return eTypeIsEnumeration | eTypeHasValue;
3906
3907 case clang::Type::FunctionProto:
3908 return eTypeIsFuncPrototype | eTypeHasValue;
3909 case clang::Type::FunctionNoProto:
3910 return eTypeIsFuncPrototype | eTypeHasValue;
3911 case clang::Type::InjectedClassName:
3912 return 0;
3913
3914 case clang::Type::LValueReference:
3915 case clang::Type::RValueReference:
3916 if (pointee_or_element_clang_type)
3917 pointee_or_element_clang_type->SetCompilerType(
3918 this, llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())
3919 ->getPointeeType()
3920 .getAsOpaquePtr());
3921 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
3922
3923 case clang::Type::MemberPointer:
3924 return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
3925
3926 case clang::Type::ObjCObjectPointer:
3927 if (pointee_or_element_clang_type)
3928 pointee_or_element_clang_type->SetCompilerType(
3929 this, qual_type->getPointeeType().getAsOpaquePtr());
3930 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer |
3931 eTypeHasValue;
3932
3933 case clang::Type::ObjCObject:
3934 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3935 case clang::Type::ObjCInterface:
3936 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3937
3938 case clang::Type::Pointer:
3939 if (pointee_or_element_clang_type)
3940 pointee_or_element_clang_type->SetCompilerType(
3941 this, qual_type->getPointeeType().getAsOpaquePtr());
3942 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
3943
3944 case clang::Type::Record:
3945 if (qual_type->getAsCXXRecordDecl())
3946 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
3947 else
3948 return eTypeHasChildren | eTypeIsStructUnion;
3949 break;
3950 case clang::Type::SubstTemplateTypeParm:
3951 return eTypeIsTemplate;
3952 case clang::Type::TemplateTypeParm:
3953 return eTypeIsTemplate;
3954 case clang::Type::TemplateSpecialization:
3955 return eTypeIsTemplate;
3956
3957 case clang::Type::Typedef:
3958 return eTypeIsTypedef | GetType(llvm::cast<clang::TypedefType>(qual_type)
3959 ->getDecl()
3960 ->getUnderlyingType())
3961 .GetTypeInfo(pointee_or_element_clang_type);
3962 case clang::Type::UnresolvedUsing:
3963 return 0;
3964
3965 case clang::Type::ExtVector:
3966 case clang::Type::Vector: {
3967 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
3968 const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
3969 qual_type->getCanonicalTypeInternal());
3970 if (vector_type) {
3971 if (vector_type->isIntegerType())
3972 vector_type_flags |= eTypeIsFloat;
3973 else if (vector_type->isFloatingType())
3974 vector_type_flags |= eTypeIsInteger;
3975 }
3976 return vector_type_flags;
3977 }
3978 default:
3979 return 0;
3980 }
3981 return 0;
3982}
3983
3984lldb::LanguageType
3985TypeSystemClang::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
3986 if (!type)
3987 return lldb::eLanguageTypeC;
3988
3989 // If the type is a reference, then resolve it to what it refers to first:
3990 clang::QualType qual_type(GetCanonicalQualType(type).getNonReferenceType());
3991 if (qual_type->isAnyPointerType()) {
3992 if (qual_type->isObjCObjectPointerType())
3993 return lldb::eLanguageTypeObjC;
3994 if (qual_type->getPointeeCXXRecordDecl())
3995 return lldb::eLanguageTypeC_plus_plus;
3996
3997 clang::QualType pointee_type(qual_type->getPointeeType());
3998 if (pointee_type->getPointeeCXXRecordDecl())
3999 return lldb::eLanguageTypeC_plus_plus;
4000 if (pointee_type->isObjCObjectOrInterfaceType())
4001 return lldb::eLanguageTypeObjC;
4002 if (pointee_type->isObjCClassType())
4003 return lldb::eLanguageTypeObjC;
4004 if (pointee_type.getTypePtr() ==
4005 getASTContext().ObjCBuiltinIdTy.getTypePtr())
4006 return lldb::eLanguageTypeObjC;
4007 } else {
4008 if (qual_type->isObjCObjectOrInterfaceType())
4009 return lldb::eLanguageTypeObjC;
4010 if (qual_type->getAsCXXRecordDecl())
4011 return lldb::eLanguageTypeC_plus_plus;
4012 switch (qual_type->getTypeClass()) {
4013 default:
4014 break;
4015 case clang::Type::Builtin:
4016 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4017 default:
4018 case clang::BuiltinType::Void:
4019 case clang::BuiltinType::Bool:
4020 case clang::BuiltinType::Char_U:
4021 case clang::BuiltinType::UChar:
4022 case clang::BuiltinType::WChar_U:
4023 case clang::BuiltinType::Char16:
4024 case clang::BuiltinType::Char32:
4025 case clang::BuiltinType::UShort:
4026 case clang::BuiltinType::UInt:
4027 case clang::BuiltinType::ULong:
4028 case clang::BuiltinType::ULongLong:
4029 case clang::BuiltinType::UInt128:
4030 case clang::BuiltinType::Char_S:
4031 case clang::BuiltinType::SChar:
4032 case clang::BuiltinType::WChar_S:
4033 case clang::BuiltinType::Short:
4034 case clang::BuiltinType::Int:
4035 case clang::BuiltinType::Long:
4036 case clang::BuiltinType::LongLong:
4037 case clang::BuiltinType::Int128:
4038 case clang::BuiltinType::Float:
4039 case clang::BuiltinType::Double:
4040 case clang::BuiltinType::LongDouble:
4041 break;
4042
4043 case clang::BuiltinType::NullPtr:
4044 return eLanguageTypeC_plus_plus;
4045
4046 case clang::BuiltinType::ObjCId:
4047 case clang::BuiltinType::ObjCClass:
4048 case clang::BuiltinType::ObjCSel:
4049 return eLanguageTypeObjC;
4050
4051 case clang::BuiltinType::Dependent:
4052 case clang::BuiltinType::Overload:
4053 case clang::BuiltinType::BoundMember:
4054 case clang::BuiltinType::UnknownAny:
4055 break;
4056 }
4057 break;
4058 case clang::Type::Typedef:
4059 return GetType(llvm::cast<clang::TypedefType>(qual_type)
4060 ->getDecl()
4061 ->getUnderlyingType())
4062 .GetMinimumLanguage();
4063 }
4064 }
4065 return lldb::eLanguageTypeC;
4066}
4067
4068lldb::TypeClass
4069TypeSystemClang::GetTypeClass(lldb::opaque_compiler_type_t type) {
4070 if (!type)
4071 return lldb::eTypeClassInvalid;
4072
4073 clang::QualType qual_type =
4074 RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
4075
4076 switch (qual_type->getTypeClass()) {
4077 case clang::Type::Atomic:
4078 case clang::Type::Auto:
4079 case clang::Type::Decltype:
4080 case clang::Type::Elaborated:
4081 case clang::Type::Paren:
4082 case clang::Type::TypeOf:
4083 case clang::Type::TypeOfExpr:
4084 llvm_unreachable("Handled in RemoveWrappingTypes!")__builtin_unreachable();
4085 case clang::Type::UnaryTransform:
4086 break;
4087 case clang::Type::FunctionNoProto:
4088 return lldb::eTypeClassFunction;
4089 case clang::Type::FunctionProto:
4090 return lldb::eTypeClassFunction;
4091 case clang::Type::IncompleteArray:
4092 return lldb::eTypeClassArray;
4093 case clang::Type::VariableArray:
4094 return lldb::eTypeClassArray;
4095 case clang::Type::ConstantArray:
4096 return lldb::eTypeClassArray;
4097 case clang::Type::DependentSizedArray:
4098 return lldb::eTypeClassArray;
4099 case clang::Type::DependentSizedExtVector:
4100 return lldb::eTypeClassVector;
4101 case clang::Type::DependentVector:
4102 return lldb::eTypeClassVector;
4103 case clang::Type::ExtVector:
4104 return lldb::eTypeClassVector;
4105 case clang::Type::Vector:
4106 return lldb::eTypeClassVector;
4107 case clang::Type::Builtin:
4108 // Ext-Int is just an integer type.
4109 case clang::Type::ExtInt:
4110 case clang::Type::DependentExtInt:
4111 return lldb::eTypeClassBuiltin;
4112 case clang::Type::ObjCObjectPointer:
4113 return lldb::eTypeClassObjCObjectPointer;
4114 case clang::Type::BlockPointer:
4115 return lldb::eTypeClassBlockPointer;
4116 case clang::Type::Pointer:
4117 return lldb::eTypeClassPointer;
4118 case clang::Type::LValueReference:
4119 return lldb::eTypeClassReference;
4120 case clang::Type::RValueReference:
4121 return lldb::eTypeClassReference;
4122 case clang::Type::MemberPointer:
4123 return lldb::eTypeClassMemberPointer;
4124 case clang::Type::Complex:
4125 if (qual_type->isComplexType())
4126 return lldb::eTypeClassComplexFloat;
4127 else
4128 return lldb::eTypeClassComplexInteger;
4129 case clang::Type::ObjCObject:
4130 return lldb::eTypeClassObjCObject;
4131 case clang::Type::ObjCInterface:
4132 return lldb::eTypeClassObjCInterface;
4133 case clang::Type::Record: {
4134 const clang::RecordType *record_type =
4135 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4136 const clang::RecordDecl *record_decl = record_type->getDecl();
4137 if (record_decl->isUnion())
4138 return lldb::eTypeClassUnion;
4139 else if (record_decl->isStruct())
4140 return lldb::eTypeClassStruct;
4141 else
4142 return lldb::eTypeClassClass;
4143 } break;
4144 case clang::Type::Enum:
4145 return lldb::eTypeClassEnumeration;
4146 case clang::Type::Typedef:
4147 return lldb::eTypeClassTypedef;
4148 case clang::Type::UnresolvedUsing:
4149 break;
4150
4151 case clang::Type::Attributed:
4152 break;
4153 case clang::Type::TemplateTypeParm:
4154 break;
4155 case clang::Type::SubstTemplateTypeParm:
4156 break;
4157 case clang::Type::SubstTemplateTypeParmPack:
4158 break;
4159 case clang::Type::InjectedClassName:
4160 break;
4161 case clang::Type::DependentName:
4162 break;
4163 case clang::Type::DependentTemplateSpecialization:
4164 break;
4165 case clang::Type::PackExpansion:
4166 break;
4167
4168 case clang::Type::TemplateSpecialization:
4169 break;
4170 case clang::Type::DeducedTemplateSpecialization:
4171 break;
4172 case clang::Type::Pipe:
4173 break;
4174
4175 // pointer type decayed from an array or function type.
4176 case clang::Type::Decayed:
4177 break;
4178 case clang::Type::Adjusted:
4179 break;
4180 case clang::Type::ObjCTypeParam:
4181 break;
4182
4183 case clang::Type::DependentAddressSpace:
4184 break;
4185 case clang::Type::MacroQualified:
4186 break;
4187
4188 // Matrix types that we're not sure how to display at the moment.
4189 case clang::Type::ConstantMatrix:
4190 case clang::Type::DependentSizedMatrix:
4191 break;
4192 }
4193 // We don't know hot to display this type...
4194 return lldb::eTypeClassOther;
4195}
4196
4197unsigned TypeSystemClang::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
4198 if (type)
4199 return GetQualType(type).getQualifiers().getCVRQualifiers();
4200 return 0;
4201}
4202
4203// Creating related types
4204
4205CompilerType
4206TypeSystemClang::GetArrayElementType(lldb::opaque_compiler_type_t type,
4207 ExecutionContextScope *exe_scope) {
4208 if (type) {
4209 clang::QualType qual_type(GetQualType(type));
4210
4211 const clang::Type *array_eletype =
4212 qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
4213
4214 if (!array_eletype)
4215 return CompilerType();
4216
4217 return GetType(clang::QualType(array_eletype, 0));
4218 }
4219 return CompilerType();
4220}
4221
4222CompilerType TypeSystemClang::GetArrayType(lldb::opaque_compiler_type_t type,
4223 uint64_t size) {
4224 if (type) {
4225 clang::QualType qual_type(GetCanonicalQualType(type));
4226 clang::ASTContext &ast_ctx = getASTContext();
4227 if (size != 0)
4228 return GetType(ast_ctx.getConstantArrayType(
4229 qual_type, llvm::APInt(64, size), nullptr,
4230 clang::ArrayType::ArraySizeModifier::Normal, 0));
4231 else
4232 return GetType(ast_ctx.getIncompleteArrayType(
4233 qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
4234 }
4235
4236 return CompilerType();
4237}
4238
4239CompilerType
4240TypeSystemClang::GetCanonicalType(lldb::opaque_compiler_type_t type) {
4241 if (type)
4242 return GetType(GetCanonicalQualType(type));
4243 return CompilerType();
4244}
4245
4246static clang::QualType GetFullyUnqualifiedType_Impl(clang::ASTContext *ast,
4247 clang::QualType qual_type) {
4248 if (qual_type->isPointerType())
4249 qual_type = ast->getPointerType(
4250 GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
4251 else
4252 qual_type = qual_type.getUnqualifiedType();
4253 qual_type.removeLocalConst();
4254 qual_type.removeLocalRestrict();
4255 qual_type.removeLocalVolatile();
4256 return qual_type;
4257}
4258
4259CompilerType
4260TypeSystemClang::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
4261 if (type)
4262 return GetType(
4263 GetFullyUnqualifiedType_Impl(&getASTContext(), GetQualType(type)));
4264 return CompilerType();
4265}
4266
4267CompilerType
4268TypeSystemClang::GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) {
4269 if (type)
4270 return GetEnumerationIntegerType(GetType(GetCanonicalQualType(type)));
4271 return CompilerType();
4272}
4273
4274int TypeSystemClang::GetFunctionArgumentCount(
4275 lldb::opaque_compiler_type_t type) {
4276 if (type) {
4277 const clang::FunctionProtoType *func =
4278 llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
4279 if (func)
4280 return func->getNumParams();
4281 }
4282 return -1;
4283}
4284
4285CompilerType TypeSystemClang::GetFunctionArgumentTypeAtIndex(
4286 lldb::opaque_compiler_type_t type, size_t idx) {
4287 if (type) {
4288 const clang::FunctionProtoType *func =
4289 llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type));
4290 if (func) {
4291 const uint32_t num_args = func->getNumParams();
4292 if (idx < num_args)
4293 return GetType(func->getParamType(idx));
4294 }
4295 }
4296 return CompilerType();
4297}
4298
4299CompilerType
4300TypeSystemClang::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
4301 if (type) {
4302 clang::QualType qual_type(GetQualType(type));
4303 const clang::FunctionProtoType *func =
4304 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
4305 if (func)
4306 return GetType(func->getReturnType());
4307 }
4308 return CompilerType();
4309}
4310
4311size_t
4312TypeSystemClang::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
4313 size_t num_functions = 0;
4314 if (type) {
4315 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
4316 switch (qual_type->getTypeClass()) {
4317 case clang::Type::Record:
4318 if (GetCompleteQualType(&getASTContext(), qual_type)) {
4319 const clang::RecordType *record_type =
4320 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4321 const clang::RecordDecl *record_decl = record_type->getDecl();
4322 assert(record_decl)((void)0);
4323 const clang::CXXRecordDecl *cxx_record_decl =
4324 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4325 if (cxx_record_decl)
4326 num_functions = std::distance(cxx_record_decl->method_begin(),
4327 cxx_record_decl->method_end());
4328 }
4329 break;
4330
4331 case clang::Type::ObjCObjectPointer: {
4332 const clang::ObjCObjectPointerType *objc_class_type =
4333 qual_type->getAs<clang::ObjCObjectPointerType>();
4334 const clang::ObjCInterfaceType *objc_interface_type =
4335 objc_class_type->getInterfaceType();
4336 if (objc_interface_type &&
4337 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
4338 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
4339 clang::ObjCInterfaceDecl *class_interface_decl =
4340 objc_interface_type->getDecl();
4341 if (class_interface_decl) {
4342 num_functions = std::distance(class_interface_decl->meth_begin(),
4343 class_interface_decl->meth_end());
4344 }
4345 }
4346 break;
4347 }
4348
4349 case clang::Type::ObjCObject:
4350 case clang::Type::ObjCInterface:
4351 if (GetCompleteType(type)) {
4352 const clang::ObjCObjectType *objc_class_type =
4353 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4354 if (objc_class_type) {
4355 clang::ObjCInterfaceDecl *class_interface_decl =
4356 objc_class_type->getInterface();
4357 if (class_interface_decl)
4358 num_functions = std::distance(class_interface_decl->meth_begin(),
4359 class_interface_decl->meth_end());
4360 }
4361 }
4362 break;
4363
4364 default:
4365 break;
4366 }
4367 }
4368 return num_functions;
4369}
4370
4371TypeMemberFunctionImpl
4372TypeSystemClang::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
4373 size_t idx) {
4374 std::string name;
4375 MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
4376 CompilerType clang_type;
4377 CompilerDecl clang_decl;
4378 if (type) {
4379 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
4380 switch (qual_type->getTypeClass()) {
4381 case clang::Type::Record:
4382 if (GetCompleteQualType(&getASTContext(), qual_type)) {
4383 const clang::RecordType *record_type =
4384 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4385 const clang::RecordDecl *record_decl = record_type->getDecl();
4386 assert(record_decl)((void)0);
4387 const clang::CXXRecordDecl *cxx_record_decl =
4388 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4389 if (cxx_record_decl) {
4390 auto method_iter = cxx_record_decl->method_begin();
4391 auto method_end = cxx_record_decl->method_end();
4392 if (idx <
4393 static_cast<size_t>(std::distance(method_iter, method_end))) {
4394 std::advance(method_iter, idx);
4395 clang::CXXMethodDecl *cxx_method_decl =
4396 method_iter->getCanonicalDecl();
4397 if (cxx_method_decl) {
4398 name = cxx_method_decl->getDeclName().getAsString();
4399 if (cxx_method_decl->isStatic())
4400 kind = lldb::eMemberFunctionKindStaticMethod;
4401 else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl))
4402 kind = lldb::eMemberFunctionKindConstructor;
4403 else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl))
4404 kind = lldb::eMemberFunctionKindDestructor;
4405 else
4406 kind = lldb::eMemberFunctionKindInstanceMethod;
4407 clang_type = GetType(cxx_method_decl->getType());
4408 clang_decl = GetCompilerDecl(cxx_method_decl);
4409 }
4410 }
4411 }
4412 }
4413 break;
4414
4415 case clang::Type::ObjCObjectPointer: {
4416 const clang::ObjCObjectPointerType *objc_class_type =
4417 qual_type->getAs<clang::ObjCObjectPointerType>();
4418 const clang::ObjCInterfaceType *objc_interface_type =
4419 objc_class_type->getInterfaceType();
4420 if (objc_interface_type &&
4421 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
4422 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
4423 clang::ObjCInterfaceDecl *class_interface_decl =
4424 objc_interface_type->getDecl();
4425 if (class_interface_decl) {
4426 auto method_iter = class_interface_decl->meth_begin();
4427 auto method_end = class_interface_decl->meth_end();
4428 if (idx <
4429 static_cast<size_t>(std::distance(method_iter, method_end))) {
4430 std::advance(method_iter, idx);
4431 clang::ObjCMethodDecl *objc_method_decl =
4432 method_iter->getCanonicalDecl();
4433 if (objc_method_decl) {
4434 clang_decl = GetCompilerDecl(objc_method_decl);
4435 name = objc_method_decl->getSelector().getAsString();
4436 if (objc_method_decl->isClassMethod())
4437 kind = lldb::eMemberFunctionKindStaticMethod;
4438 else
4439 kind = lldb::eMemberFunctionKindInstanceMethod;
4440 }
4441 }
4442 }
4443 }
4444 break;
4445 }
4446
4447 case clang::Type::ObjCObject:
4448 case clang::Type::ObjCInterface:
4449 if (GetCompleteType(type)) {
4450 const clang::ObjCObjectType *objc_class_type =
4451 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4452 if (objc_class_type) {
4453 clang::ObjCInterfaceDecl *class_interface_decl =
4454 objc_class_type->getInterface();
4455 if (class_interface_decl) {
4456 auto method_iter = class_interface_decl->meth_begin();
4457 auto method_end = class_interface_decl->meth_end();
4458 if (idx <
4459 static_cast<size_t>(std::distance(method_iter, method_end))) {
4460 std::advance(method_iter, idx);
4461 clang::ObjCMethodDecl *objc_method_decl =
4462 method_iter->getCanonicalDecl();
4463 if (objc_method_decl) {
4464 clang_decl = GetCompilerDecl(objc_method_decl);
4465 name = objc_method_decl->getSelector().getAsString();
4466 if (objc_method_decl->isClassMethod())
4467 kind = lldb::eMemberFunctionKindStaticMethod;
4468 else
4469 kind = lldb::eMemberFunctionKindInstanceMethod;
4470 }
4471 }
4472 }
4473 }
4474 }
4475 break;
4476
4477 default:
4478 break;
4479 }
4480 }
4481
4482 if (kind == eMemberFunctionKindUnknown)
4483 return TypeMemberFunctionImpl();
4484 else
4485 return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind);
4486}
4487
4488CompilerType
4489TypeSystemClang::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
4490 if (type)
4491 return GetType(GetQualType(type).getNonReferenceType());
4492 return CompilerType();
4493}
4494
4495CompilerType
4496TypeSystemClang::GetPointeeType(lldb::opaque_compiler_type_t type) {
4497 if (type) {
4498 clang::QualType qual_type(GetQualType(type));
4499 return GetType(qual_type.getTypePtr()->getPointeeType());
4500 }
4501 return CompilerType();
4502}
4503
4504CompilerType
4505TypeSystemClang::GetPointerType(lldb::opaque_compiler_type_t type) {
4506 if (type) {
4507 clang::QualType qual_type(GetQualType(type));
4508
4509 switch (qual_type.getDesugaredType(getASTContext())->getTypeClass()) {
4510 case clang::Type::ObjCObject:
4511 case clang::Type::ObjCInterface:
4512 return GetType(getASTContext().getObjCObjectPointerType(qual_type));
4513
4514 default:
4515 return GetType(getASTContext().getPointerType(qual_type));
4516 }
4517 }
4518 return CompilerType();
4519}
4520
4521CompilerType
4522TypeSystemClang::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
4523 if (type)
4524 return GetType(getASTContext().getLValueReferenceType(GetQualType(type)));
4525 else
4526 return CompilerType();
4527}
4528
4529CompilerType
4530TypeSystemClang::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
4531 if (type)
4532 return GetType(getASTContext().getRValueReferenceType(GetQualType(type)));
4533 else
4534 return CompilerType();
4535}
4536
4537CompilerType TypeSystemClang::GetAtomicType(lldb::opaque_compiler_type_t type) {
4538 if (!type)
4539 return CompilerType();
4540 return GetType(getASTContext().getAtomicType(GetQualType(type)));
4541}
4542
4543CompilerType
4544TypeSystemClang::AddConstModifier(lldb::opaque_compiler_type_t type) {
4545 if (type) {
4546 clang::QualType result(GetQualType(type));
4547 result.addConst();
4548 return GetType(result);
4549 }
4550 return CompilerType();
4551}
4552
4553CompilerType
4554TypeSystemClang::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
4555 if (type) {
4556 clang::QualType result(GetQualType(type));
4557 result.addVolatile();
4558 return GetType(result);
4559 }
4560 return CompilerType();
4561}
4562
4563CompilerType
4564TypeSystemClang::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
4565 if (type) {
4566 clang::QualType result(GetQualType(type));
4567 result.addRestrict();
4568 return GetType(result);
4569 }
4570 return CompilerType();
4571}
4572
4573CompilerType TypeSystemClang::CreateTypedef(
4574 lldb::opaque_compiler_type_t type, const char *typedef_name,
4575 const CompilerDeclContext &compiler_decl_ctx, uint32_t payload) {
4576 if (type && typedef_name && typedef_name[0]) {
4577 clang::ASTContext &clang_ast = getASTContext();
4578 clang::QualType qual_type(GetQualType(type));
4579
4580 clang::DeclContext *decl_ctx =
4581 TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
4582 if (!decl_ctx)
4583 decl_ctx = getASTContext().getTranslationUnitDecl();
4584
4585 clang::TypedefDecl *decl =
4586 clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
4587 decl->setDeclContext(decl_ctx);
4588 decl->setDeclName(&clang_ast.Idents.get(typedef_name));
4589 decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
4590 decl_ctx->addDecl(decl);
4591 SetOwningModule(decl, TypePayloadClang(payload).GetOwningModule());
4592
4593 clang::TagDecl *tdecl = nullptr;
4594 if (!qual_type.isNull()) {
4595 if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
4596 tdecl = rt->getDecl();
4597 if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
4598 tdecl = et->getDecl();
4599 }
4600
4601 // Check whether this declaration is an anonymous struct, union, or enum,
4602 // hidden behind a typedef. If so, we try to check whether we have a
4603 // typedef tag to attach to the original record declaration
4604 if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
4605 tdecl->setTypedefNameForAnonDecl(decl);
4606
4607 decl->setAccess(clang::AS_public); // TODO respect proper access specifier
4608
4609 // Get a uniqued clang::QualType for the typedef decl type
4610 return GetType(clang_ast.getTypedefType(decl));
4611 }
4612 return CompilerType();
4613}
4614
4615CompilerType
4616TypeSystemClang::GetTypedefedType(lldb::opaque_compiler_type_t type) {
4617 if (type) {
4618 const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(
4619 RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef}));
4620 if (typedef_type)
4621 return GetType(typedef_type->getDecl()->getUnderlyingType());
4622 }
4623 return CompilerType();
4624}
4625
4626// Create related types using the current type's AST
4627
4628CompilerType TypeSystemClang::GetBasicTypeFromAST(lldb::BasicType basic_type) {
4629 return TypeSystemClang::GetBasicType(basic_type);
4630}
4631// Exploring the type
4632
4633const llvm::fltSemantics &
4634TypeSystemClang::GetFloatTypeSemantics(size_t byte_size) {
4635 clang::ASTContext &ast = getASTContext();
4636 const size_t bit_size = byte_size * 8;
4637 if (bit_size == ast.getTypeSize(ast.FloatTy))
4638 return ast.getFloatTypeSemantics(ast.FloatTy);
4639 else if (bit_size == ast.getTypeSize(ast.DoubleTy))
4640 return ast.getFloatTypeSemantics(ast.DoubleTy);
4641 else if (bit_size == ast.getTypeSize(ast.LongDoubleTy))
4642 return ast.getFloatTypeSemantics(ast.LongDoubleTy);
4643 else if (bit_size == ast.getTypeSize(ast.HalfTy))
4644 return ast.getFloatTypeSemantics(ast.HalfTy);
4645 return llvm::APFloatBase::Bogus();
4646}
4647
4648Optional<uint64_t>
4649TypeSystemClang::GetBitSize(lldb::opaque_compiler_type_t type,
4650 ExecutionContextScope *exe_scope) {
4651 if (GetCompleteType(type)) {
4652 clang::QualType qual_type(GetCanonicalQualType(type));
4653 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4654 switch (type_class) {
4655 case clang::Type::Record:
4656 if (GetCompleteType(type))
4657 return getASTContext().getTypeSize(qual_type);
4658 else
4659 return None;
4660 break;
4661
4662 case clang::Type::ObjCInterface:
4663 case clang::Type::ObjCObject: {
4664 ExecutionContext exe_ctx(exe_scope);
4665 Process *process = exe_ctx.GetProcessPtr();
4666 if (process) {
4667 ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
4668 if (objc_runtime) {
4669 uint64_t bit_size = 0;
4670 if (objc_runtime->GetTypeBitSize(GetType(qual_type), bit_size))
4671 return bit_size;
4672 }
4673 } else {
4674 static bool g_printed = false;
4675 if (!g_printed) {
4676 StreamString s;
4677 DumpTypeDescription(type, &s);
4678
4679 llvm::outs() << "warning: trying to determine the size of type ";
4680 llvm::outs() << s.GetString() << "\n";
4681 llvm::outs() << "without a valid ExecutionContext. this is not "
4682 "reliable. please file a bug against LLDB.\n";
4683 llvm::outs() << "backtrace:\n";
4684 llvm::sys::PrintStackTrace(llvm::outs());
4685 llvm::outs() << "\n";
4686 g_printed = true;
4687 }
4688 }
4689 }
4690 LLVM_FALLTHROUGH[[gnu::fallthrough]];
4691 default:
4692 const uint32_t bit_size = getASTContext().getTypeSize(qual_type);
4693 if (bit_size == 0) {
4694 if (qual_type->isIncompleteArrayType())
4695 return getASTContext().getTypeSize(
4696 qual_type->getArrayElementTypeNoTypeQual()
4697 ->getCanonicalTypeUnqualified());
4698 }
4699 if (qual_type->isObjCObjectOrInterfaceType())
4700 return bit_size +
4701 getASTContext().getTypeSize(getASTContext().ObjCBuiltinClassTy);
4702 // Function types actually have a size of 0, that's not an error.
4703 if (qual_type->isFunctionProtoType())
4704 return bit_size;
4705 if (bit_size)
4706 return bit_size;
4707 }
4708 }
4709 return None;
4710}
4711
4712llvm::Optional<size_t>
4713TypeSystemClang::GetTypeBitAlign(lldb::opaque_compiler_type_t type,
4714 ExecutionContextScope *exe_scope) {
4715 if (GetCompleteType(type))
4716 return getASTContext().getTypeAlign(GetQualType(type));
4717 return {};
4718}
4719
4720lldb::Encoding TypeSystemClang::GetEncoding(lldb::opaque_compiler_type_t type,
4721 uint64_t &count) {
4722 if (!type)
4723 return lldb::eEncodingInvalid;
4724
4725 count = 1;
4726 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
4727
4728 switch (qual_type->getTypeClass()) {
4729 case clang::Type::Atomic:
4730 case clang::Type::Auto:
4731 case clang::Type::Decltype:
4732 case clang::Type::Elaborated:
4733 case clang::Type::Paren:
4734 case clang::Type::Typedef:
4735 case clang::Type::TypeOf:
4736 case clang::Type::TypeOfExpr:
4737 llvm_unreachable("Handled in RemoveWrappingTypes!")__builtin_unreachable();
4738
4739 case clang::Type::UnaryTransform:
4740 break;
4741
4742 case clang::Type::FunctionNoProto:
4743 case clang::Type::FunctionProto:
4744 break;
4745
4746 case clang::Type::IncompleteArray:
4747 case clang::Type::VariableArray:
4748 break;
4749
4750 case clang::Type::ConstantArray:
4751 break;
4752
4753 case clang::Type::DependentVector:
4754 case clang::Type::ExtVector:
4755 case clang::Type::Vector:
4756 // TODO: Set this to more than one???
4757 break;
4758
4759 case clang::Type::ExtInt:
4760 case clang::Type::DependentExtInt:
4761 return qual_type->isUnsignedIntegerType() ? lldb::eEncodingUint
4762 : lldb::eEncodingSint;
4763
4764 case clang::Type::Builtin:
4765 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4766 case clang::BuiltinType::Void:
4767 break;
4768
4769 case clang::BuiltinType::Char_S:
4770 case clang::BuiltinType::SChar:
4771 case clang::BuiltinType::WChar_S:
4772 case clang::BuiltinType::Short:
4773 case clang::BuiltinType::Int:
4774 case clang::BuiltinType::Long:
4775 case clang::BuiltinType::LongLong:
4776 case clang::BuiltinType::Int128:
4777 return lldb::eEncodingSint;
4778
4779 case clang::BuiltinType::Bool:
4780 case clang::BuiltinType::Char_U:
4781 case clang::BuiltinType::UChar:
4782 case clang::BuiltinType::WChar_U:
4783 case clang::BuiltinType::Char8:
4784 case clang::BuiltinType::Char16:
4785 case clang::BuiltinType::Char32:
4786 case clang::BuiltinType::UShort:
4787 case clang::BuiltinType::UInt:
4788 case clang::BuiltinType::ULong:
4789 case clang::BuiltinType::ULongLong:
4790 case clang::BuiltinType::UInt128:
4791 return lldb::eEncodingUint;
4792
4793 // Fixed point types. Note that they are currently ignored.
4794 case clang::BuiltinType::ShortAccum:
4795 case clang::BuiltinType::Accum:
4796 case clang::BuiltinType::LongAccum:
4797 case clang::BuiltinType::UShortAccum:
4798 case clang::BuiltinType::UAccum:
4799 case clang::BuiltinType::ULongAccum:
4800 case clang::BuiltinType::ShortFract:
4801 case clang::BuiltinType::Fract:
4802 case clang::BuiltinType::LongFract:
4803 case clang::BuiltinType::UShortFract:
4804 case clang::BuiltinType::UFract:
4805 case clang::BuiltinType::ULongFract:
4806 case clang::BuiltinType::SatShortAccum:
4807 case clang::BuiltinType::SatAccum:
4808 case clang::BuiltinType::SatLongAccum:
4809 case clang::BuiltinType::SatUShortAccum:
4810 case clang::BuiltinType::SatUAccum:
4811 case clang::BuiltinType::SatULongAccum:
4812 case clang::BuiltinType::SatShortFract:
4813 case clang::BuiltinType::SatFract:
4814 case clang::BuiltinType::SatLongFract:
4815 case clang::BuiltinType::SatUShortFract:
4816 case clang::BuiltinType::SatUFract:
4817 case clang::BuiltinType::SatULongFract:
4818 break;
4819
4820 case clang::BuiltinType::Half:
4821 case clang::BuiltinType::Float:
4822 case clang::BuiltinType::Float16:
4823 case clang::BuiltinType::Float128:
4824 case clang::BuiltinType::Double:
4825 case clang::BuiltinType::LongDouble:
4826 case clang::BuiltinType::BFloat16:
4827 return lldb::eEncodingIEEE754;
4828
4829 case clang::BuiltinType::ObjCClass:
4830 case clang::BuiltinType::ObjCId:
4831 case clang::BuiltinType::ObjCSel:
4832 return lldb::eEncodingUint;
4833
4834 case clang::BuiltinType::NullPtr:
4835 return lldb::eEncodingUint;
4836
4837 case clang::BuiltinType::Kind::ARCUnbridgedCast:
4838 case clang::BuiltinType::Kind::BoundMember:
4839 case clang::BuiltinType::Kind::BuiltinFn:
4840 case clang::BuiltinType::Kind::Dependent:
4841 case clang::BuiltinType::Kind::OCLClkEvent:
4842 case clang::BuiltinType::Kind::OCLEvent:
4843 case clang::BuiltinType::Kind::OCLImage1dRO:
4844 case clang::BuiltinType::Kind::OCLImage1dWO:
4845 case clang::BuiltinType::Kind::OCLImage1dRW:
4846 case clang::BuiltinType::Kind::OCLImage1dArrayRO:
4847 case clang::BuiltinType::Kind::OCLImage1dArrayWO:
4848 case clang::BuiltinType::Kind::OCLImage1dArrayRW:
4849 case clang::BuiltinType::Kind::OCLImage1dBufferRO:
4850 case clang::BuiltinType::Kind::OCLImage1dBufferWO:
4851 case clang::BuiltinType::Kind::OCLImage1dBufferRW:
4852 case clang::BuiltinType::Kind::OCLImage2dRO:
4853 case clang::BuiltinType::Kind::OCLImage2dWO:
4854 case clang::BuiltinType::Kind::OCLImage2dRW:
4855 case clang::BuiltinType::Kind::OCLImage2dArrayRO:
4856 case clang::BuiltinType::Kind::OCLImage2dArrayWO:
4857 case clang::BuiltinType::Kind::OCLImage2dArrayRW:
4858 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO:
4859 case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO:
4860 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW:
4861 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO:
4862 case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO:
4863 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW:
4864 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO:
4865 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO:
4866 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW:
4867 case clang::BuiltinType::Kind::OCLImage2dDepthRO:
4868 case clang::BuiltinType::Kind::OCLImage2dDepthWO:
4869 case clang::BuiltinType::Kind::OCLImage2dDepthRW:
4870 case clang::BuiltinType::Kind::OCLImage2dMSAARO:
4871 case clang::BuiltinType::Kind::OCLImage2dMSAAWO:
4872 case clang::BuiltinType::Kind::OCLImage2dMSAARW:
4873 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO:
4874 case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO:
4875 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW:
4876 case clang::BuiltinType::Kind::OCLImage3dRO:
4877 case clang::BuiltinType::Kind::OCLImage3dWO:
4878 case clang::BuiltinType::Kind::OCLImage3dRW:
4879 case clang::BuiltinType::Kind::OCLQueue:
4880 case clang::BuiltinType::Kind::OCLReserveID:
4881 case clang::BuiltinType::Kind::OCLSampler:
4882 case clang::BuiltinType::Kind::OMPArraySection:
4883 case clang::BuiltinType::Kind::OMPArrayShaping:
4884 case clang::BuiltinType::Kind::OMPIterator:
4885 case clang::BuiltinType::Kind::Overload:
4886 case clang::BuiltinType::Kind::PseudoObject:
4887 case clang::BuiltinType::Kind::UnknownAny:
4888 break;
4889
4890 case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
4891 case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
4892 case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
4893 case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
4894 case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
4895 case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
4896 case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
4897 case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
4898 case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
4899 case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
4900 case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
4901 case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
4902 break;
4903
4904 // PowerPC -- Matrix Multiply Assist
4905 case clang::BuiltinType::VectorPair:
4906 case clang::BuiltinType::VectorQuad:
4907 break;
4908
4909 // ARM -- Scalable Vector Extension
4910 case clang::BuiltinType::SveBool:
4911 case clang::BuiltinType::SveInt8:
4912 case clang::BuiltinType::SveInt8x2:
4913 case clang::BuiltinType::SveInt8x3:
4914 case clang::BuiltinType::SveInt8x4:
4915 case clang::BuiltinType::SveInt16:
4916 case clang::BuiltinType::SveInt16x2:
4917 case clang::BuiltinType::SveInt16x3:
4918 case clang::BuiltinType::SveInt16x4:
4919 case clang::BuiltinType::SveInt32:
4920 case clang::BuiltinType::SveInt32x2:
4921 case clang::BuiltinType::SveInt32x3:
4922 case clang::BuiltinType::SveInt32x4:
4923 case clang::BuiltinType::SveInt64:
4924 case clang::BuiltinType::SveInt64x2:
4925 case clang::BuiltinType::SveInt64x3:
4926 case clang::BuiltinType::SveInt64x4:
4927 case clang::BuiltinType::SveUint8:
4928 case clang::BuiltinType::SveUint8x2:
4929 case clang::BuiltinType::SveUint8x3:
4930 case clang::BuiltinType::SveUint8x4:
4931 case clang::BuiltinType::SveUint16:
4932 case clang::BuiltinType::SveUint16x2:
4933 case clang::BuiltinType::SveUint16x3:
4934 case clang::BuiltinType::SveUint16x4:
4935 case clang::BuiltinType::SveUint32:
4936 case clang::BuiltinType::SveUint32x2:
4937 case clang::BuiltinType::SveUint32x3:
4938 case clang::BuiltinType::SveUint32x4:
4939 case clang::BuiltinType::SveUint64:
4940 case clang::BuiltinType::SveUint64x2:
4941 case clang::BuiltinType::SveUint64x3:
4942 case clang::BuiltinType::SveUint64x4:
4943 case clang::BuiltinType::SveFloat16:
4944 case clang::BuiltinType::SveBFloat16:
4945 case clang::BuiltinType::SveBFloat16x2:
4946 case clang::BuiltinType::SveBFloat16x3:
4947 case clang::BuiltinType::SveBFloat16x4:
4948 case clang::BuiltinType::SveFloat16x2:
4949 case clang::BuiltinType::SveFloat16x3:
4950 case clang::BuiltinType::SveFloat16x4:
4951 case clang::BuiltinType::SveFloat32:
4952 case clang::BuiltinType::SveFloat32x2:
4953 case clang::BuiltinType::SveFloat32x3:
4954 case clang::BuiltinType::SveFloat32x4:
4955 case clang::BuiltinType::SveFloat64:
4956 case clang::BuiltinType::SveFloat64x2:
4957 case clang::BuiltinType::SveFloat64x3:
4958 case clang::BuiltinType::SveFloat64x4:
4959 break;
4960
4961 // RISC-V V builtin types.
4962 case clang::BuiltinType::RvvInt8mf8:
4963 case clang::BuiltinType::RvvInt8mf4:
4964 case clang::BuiltinType::RvvInt8mf2:
4965 case clang::BuiltinType::RvvInt8m1:
4966 case clang::BuiltinType::RvvInt8m2:
4967 case clang::BuiltinType::RvvInt8m4:
4968 case clang::BuiltinType::RvvInt8m8:
4969 case clang::BuiltinType::RvvUint8mf8:
4970 case clang::BuiltinType::RvvUint8mf4:
4971 case clang::BuiltinType::RvvUint8mf2:
4972 case clang::BuiltinType::RvvUint8m1:
4973 case clang::BuiltinType::RvvUint8m2:
4974 case clang::BuiltinType::RvvUint8m4:
4975 case clang::BuiltinType::RvvUint8m8:
4976 case clang::BuiltinType::RvvInt16mf4:
4977 case clang::BuiltinType::RvvInt16mf2:
4978 case clang::BuiltinType::RvvInt16m1:
4979 case clang::BuiltinType::RvvInt16m2:
4980 case clang::BuiltinType::RvvInt16m4:
4981 case clang::BuiltinType::RvvInt16m8:
4982 case clang::BuiltinType::RvvUint16mf4:
4983 case clang::BuiltinType::RvvUint16mf2:
4984 case clang::BuiltinType::RvvUint16m1:
4985 case clang::BuiltinType::RvvUint16m2:
4986 case clang::BuiltinType::RvvUint16m4:
4987 case clang::BuiltinType::RvvUint16m8:
4988 case clang::BuiltinType::RvvInt32mf2:
4989 case clang::BuiltinType::RvvInt32m1:
4990 case clang::BuiltinType::RvvInt32m2:
4991 case clang::BuiltinType::RvvInt32m4:
4992 case clang::BuiltinType::RvvInt32m8:
4993 case clang::BuiltinType::RvvUint32mf2:
4994 case clang::BuiltinType::RvvUint32m1:
4995 case clang::BuiltinType::RvvUint32m2:
4996 case clang::BuiltinType::RvvUint32m4:
4997 case clang::BuiltinType::RvvUint32m8:
4998 case clang::BuiltinType::RvvInt64m1:
4999 case clang::BuiltinType::RvvInt64m2:
5000 case clang::BuiltinType::RvvInt64m4:
5001 case clang::BuiltinType::RvvInt64m8:
5002 case clang::BuiltinType::RvvUint64m1:
5003 case clang::BuiltinType::RvvUint64m2:
5004 case clang::BuiltinType::RvvUint64m4:
5005 case clang::BuiltinType::RvvUint64m8:
5006 case clang::BuiltinType::RvvFloat16mf4:
5007 case clang::BuiltinType::RvvFloat16mf2:
5008 case clang::BuiltinType::RvvFloat16m1:
5009 case clang::BuiltinType::RvvFloat16m2:
5010 case clang::BuiltinType::RvvFloat16m4:
5011 case clang::BuiltinType::RvvFloat16m8:
5012 case clang::BuiltinType::RvvFloat32mf2:
5013 case clang::BuiltinType::RvvFloat32m1:
5014 case clang::BuiltinType::RvvFloat32m2:
5015 case clang::BuiltinType::RvvFloat32m4:
5016 case clang::BuiltinType::RvvFloat32m8:
5017 case clang::BuiltinType::RvvFloat64m1:
5018 case clang::BuiltinType::RvvFloat64m2:
5019 case clang::BuiltinType::RvvFloat64m4:
5020 case clang::BuiltinType::RvvFloat64m8:
5021 case clang::BuiltinType::RvvBool1:
5022 case clang::BuiltinType::RvvBool2:
5023 case clang::BuiltinType::RvvBool4:
5024 case clang::BuiltinType::RvvBool8:
5025 case clang::BuiltinType::RvvBool16:
5026 case clang::BuiltinType::RvvBool32:
5027 case clang::BuiltinType::RvvBool64:
5028 break;
5029
5030 case clang::BuiltinType::IncompleteMatrixIdx:
5031 break;
5032 }
5033 break;
5034 // All pointer types are represented as unsigned integer encodings. We may
5035 // nee to add a eEncodingPointer if we ever need to know the difference
5036 case clang::Type::ObjCObjectPointer:
5037 case clang::Type::BlockPointer:
5038 case clang::Type::Pointer:
5039 case clang::Type::LValueReference:
5040 case clang::Type::RValueReference:
5041 case clang::Type::MemberPointer:
5042 return lldb::eEncodingUint;
5043 case clang::Type::Complex: {
5044 lldb::Encoding encoding = lldb::eEncodingIEEE754;
5045 if (qual_type->isComplexType())
5046 encoding = lldb::eEncodingIEEE754;
5047 else {
5048 const clang::ComplexType *complex_type =
5049 qual_type->getAsComplexIntegerType();
5050 if (complex_type)
5051 encoding = GetType(complex_type->getElementType()).GetEncoding(count);
5052 else
5053 encoding = lldb::eEncodingSint;
5054 }
5055 count = 2;
5056 return encoding;
5057 }
5058
5059 case clang::Type::ObjCInterface:
5060 break;
5061 case clang::Type::Record:
5062 break;
5063 case clang::Type::Enum:
5064 return lldb::eEncodingSint;
5065 case clang::Type::DependentSizedArray:
5066 case clang::Type::DependentSizedExtVector:
5067 case clang::Type::UnresolvedUsing:
5068 case clang::Type::Attributed:
5069 case clang::Type::TemplateTypeParm:
5070 case clang::Type::SubstTemplateTypeParm:
5071 case clang::Type::SubstTemplateTypeParmPack:
5072 case clang::Type::InjectedClassName:
5073 case clang::Type::DependentName:
5074 case clang::Type::DependentTemplateSpecialization:
5075 case clang::Type::PackExpansion:
5076 case clang::Type::ObjCObject:
5077
5078 case clang::Type::TemplateSpecialization:
5079 case clang::Type::DeducedTemplateSpecialization:
5080 case clang::Type::Adjusted:
5081 case clang::Type::Pipe:
5082 break;
5083
5084 // pointer type decayed from an array or function type.
5085 case clang::Type::Decayed:
5086 break;
5087 case clang::Type::ObjCTypeParam:
5088 break;
5089
5090 case clang::Type::DependentAddressSpace:
5091 break;
5092 case clang::Type::MacroQualified:
5093 break;
5094
5095 case clang::Type::ConstantMatrix:
5096 case clang::Type::DependentSizedMatrix:
5097 break;
5098 }
5099 count = 0;
5100 return lldb::eEncodingInvalid;
5101}
5102
5103lldb::Format TypeSystemClang::GetFormat(lldb::opaque_compiler_type_t type) {
5104 if (!type)
5105 return lldb::eFormatDefault;
5106
5107 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5108
5109 switch (qual_type->getTypeClass()) {
5110 case clang::Type::Atomic:
5111 case clang::Type::Auto:
5112 case clang::Type::Decltype:
5113 case clang::Type::Elaborated:
5114 case clang::Type::Paren:
5115 case clang::Type::Typedef:
5116 case clang::Type::TypeOf:
5117 case clang::Type::TypeOfExpr:
5118 llvm_unreachable("Handled in RemoveWrappingTypes!")__builtin_unreachable();
5119 case clang::Type::UnaryTransform:
5120 break;
5121
5122 case clang::Type::FunctionNoProto:
5123 case clang::Type::FunctionProto:
5124 break;
5125
5126 case clang::Type::IncompleteArray:
5127 case clang::Type::VariableArray:
5128 break;
5129
5130 case clang::Type::ConstantArray:
5131 return lldb::eFormatVoid; // no value
5132
5133 case clang::Type::DependentVector:
5134 case clang::Type::ExtVector:
5135 case clang::Type::Vector:
5136 break;
5137
5138 case clang::Type::ExtInt:
5139 case clang::Type::DependentExtInt:
5140 return qual_type->isUnsignedIntegerType() ? lldb::eFormatUnsigned
5141 : lldb::eFormatDecimal;
5142
5143 case clang::Type::Builtin:
5144 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5145 case clang::BuiltinType::UnknownAny:
5146 case clang::BuiltinType::Void:
5147 case clang::BuiltinType::BoundMember:
5148 break;
5149
5150 case clang::BuiltinType::Bool:
5151 return lldb::eFormatBoolean;
5152 case clang::BuiltinType::Char_S:
5153 case clang::BuiltinType::SChar:
5154 case clang::BuiltinType::WChar_S:
5155 case clang::BuiltinType::Char_U:
5156 case clang::BuiltinType::UChar:
5157 case clang::BuiltinType::WChar_U:
5158 return lldb::eFormatChar;
5159 case clang::BuiltinType::Char16:
5160 return lldb::eFormatUnicode16;
5161 case clang::BuiltinType::Char32:
5162 return lldb::eFormatUnicode32;
5163 case clang::BuiltinType::UShort:
5164 return lldb::eFormatUnsigned;
5165 case clang::BuiltinType::Short:
5166 return lldb::eFormatDecimal;
5167 case clang::BuiltinType::UInt:
5168 return lldb::eFormatUnsigned;
5169 case clang::BuiltinType::Int:
5170 return lldb::eFormatDecimal;
5171 case clang::BuiltinType::ULong:
5172 return lldb::eFormatUnsigned;
5173 case clang::BuiltinType::Long:
5174 return lldb::eFormatDecimal;
5175 case clang::BuiltinType::ULongLong:
5176 return lldb::eFormatUnsigned;
5177 case clang::BuiltinType::LongLong:
5178 return lldb::eFormatDecimal;
5179 case clang::BuiltinType::UInt128:
5180 return lldb::eFormatUnsigned;
5181 case clang::BuiltinType::Int128:
5182 return lldb::eFormatDecimal;
5183 case clang::BuiltinType::Half:
5184 case clang::BuiltinType::Float:
5185 case clang::BuiltinType::Double:
5186 case clang::BuiltinType::LongDouble:
5187 return lldb::eFormatFloat;
5188 default:
5189 return lldb::eFormatHex;
5190 }
5191 break;
5192 case clang::Type::ObjCObjectPointer:
5193 return lldb::eFormatHex;
5194 case clang::Type::BlockPointer:
5195 return lldb::eFormatHex;
5196 case clang::Type::Pointer:
5197 return lldb::eFormatHex;
5198 case clang::Type::LValueReference:
5199 case clang::Type::RValueReference:
5200 return lldb::eFormatHex;
5201 case clang::Type::MemberPointer:
5202 break;
5203 case clang::Type::Complex: {
5204 if (qual_type->isComplexType())
5205 return lldb::eFormatComplex;
5206 else
5207 return lldb::eFormatComplexInteger;
5208 }
5209 case clang::Type::ObjCInterface:
5210 break;
5211 case clang::Type::Record:
5212 break;
5213 case clang::Type::Enum:
5214 return lldb::eFormatEnum;
5215 case clang::Type::DependentSizedArray:
5216 case clang::Type::DependentSizedExtVector:
5217 case clang::Type::UnresolvedUsing:
5218 case clang::Type::Attributed:
5219 case clang::Type::TemplateTypeParm:
5220 case clang::Type::SubstTemplateTypeParm:
5221 case clang::Type::SubstTemplateTypeParmPack:
5222 case clang::Type::InjectedClassName:
5223 case clang::Type::DependentName:
5224 case clang::Type::DependentTemplateSpecialization:
5225 case clang::Type::PackExpansion:
5226 case clang::Type::ObjCObject:
5227
5228 case clang::Type::TemplateSpecialization:
5229 case clang::Type::DeducedTemplateSpecialization:
5230 case clang::Type::Adjusted:
5231 case clang::Type::Pipe:
5232 break;
5233
5234 // pointer type decayed from an array or function type.
5235 case clang::Type::Decayed:
5236 break;
5237 case clang::Type::ObjCTypeParam:
5238 break;
5239
5240 case clang::Type::DependentAddressSpace:
5241 break;
5242 case clang::Type::MacroQualified:
5243 break;
5244
5245 // Matrix types we're not sure how to display yet.
5246 case clang::Type::ConstantMatrix:
5247 case clang::Type::DependentSizedMatrix:
5248 break;
5249 }
5250 // We don't know hot to display this type...
5251 return lldb::eFormatBytes;
5252}
5253
5254static bool ObjCDeclHasIVars(clang::ObjCInterfaceDecl *class_interface_decl,
5255 bool check_superclass) {
5256 while (class_interface_decl) {
5257 if (class_interface_decl->ivar_size() > 0)
5258 return true;
5259
5260 if (check_superclass)
5261 class_interface_decl = class_interface_decl->getSuperClass();
5262 else
5263 break;
5264 }
5265 return false;
5266}
5267
5268static Optional<SymbolFile::ArrayInfo>
5269GetDynamicArrayInfo(TypeSystemClang &ast, SymbolFile *sym_file,
5270 clang::QualType qual_type,
5271 const ExecutionContext *exe_ctx) {
5272 if (qual_type->isIncompleteArrayType())
5273 if (auto *metadata = ast.GetMetadata(qual_type.getTypePtr()))
5274 return sym_file->GetDynamicArrayInfoForUID(metadata->GetUserID(),
5275 exe_ctx);
5276 return llvm::None;
5277}
5278
5279uint32_t TypeSystemClang::GetNumChildren(lldb::opaque_compiler_type_t type,
5280 bool omit_empty_base_classes,
5281 const ExecutionContext *exe_ctx) {
5282 if (!type)
5283 return 0;
5284
5285 uint32_t num_children = 0;
5286 clang::QualType qual_type(RemoveWrappingTypes(GetQualType(type)));
5287 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5288 switch (type_class) {
5289 case clang::Type::Builtin:
5290 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5291 case clang::BuiltinType::ObjCId: // child is Class
5292 case clang::BuiltinType::ObjCClass: // child is Class
5293 num_children = 1;
5294 break;
5295
5296 default:
5297 break;
5298 }
5299 break;
5300
5301 case clang::Type::Complex:
5302 return 0;
5303 case clang::Type::Record:
5304 if (GetCompleteQualType(&getASTContext(), qual_type)) {
5305 const clang::RecordType *record_type =
5306 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5307 const clang::RecordDecl *record_decl = record_type->getDecl();
5308 assert(record_decl)((void)0);
5309 const clang::CXXRecordDecl *cxx_record_decl =
5310 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5311 if (cxx_record_decl) {
5312 if (omit_empty_base_classes) {
5313 // Check each base classes to see if it or any of its base classes
5314 // contain any fields. This can help limit the noise in variable
5315 // views by not having to show base classes that contain no members.
5316 clang::CXXRecordDecl::base_class_const_iterator base_class,
5317 base_class_end;
5318 for (base_class = cxx_record_decl->bases_begin(),
5319 base_class_end = cxx_record_decl->bases_end();
5320 base_class != base_class_end; ++base_class) {
5321 const clang::CXXRecordDecl *base_class_decl =
5322 llvm::cast<clang::CXXRecordDecl>(
5323 base_class->getType()
5324 ->getAs<clang::RecordType>()
5325 ->getDecl());
5326
5327 // Skip empty base classes
5328 if (!TypeSystemClang::RecordHasFields(base_class_decl))
5329 continue;
5330
5331 num_children++;
5332 }
5333 } else {
5334 // Include all base classes
5335 num_children += cxx_record_decl->getNumBases();
5336 }
5337 }
5338 clang::RecordDecl::field_iterator field, field_end;
5339 for (field = record_decl->field_begin(),
5340 field_end = record_decl->field_end();
5341 field != field_end; ++field)
5342 ++num_children;
5343 }
5344 break;
5345
5346 case clang::Type::ObjCObject:
5347 case clang::Type::ObjCInterface:
5348 if (GetCompleteQualType(&getASTContext(), qual_type)) {
5349 const clang::ObjCObjectType *objc_class_type =
5350 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5351 assert(objc_class_type)((void)0);
5352 if (objc_class_type) {
5353 clang::ObjCInterfaceDecl *class_interface_decl =
5354 objc_class_type->getInterface();
5355
5356 if (class_interface_decl) {
5357
5358 clang::ObjCInterfaceDecl *superclass_interface_decl =
5359 class_interface_decl->getSuperClass();
5360 if (superclass_interface_decl) {
5361 if (omit_empty_base_classes) {
5362 if (ObjCDeclHasIVars(superclass_interface_decl, true))
5363 ++num_children;
5364 } else
5365 ++num_children;
5366 }
5367
5368 num_children += class_interface_decl->ivar_size();
5369 }
5370 }
5371 }
5372 break;
5373
5374 case clang::Type::LValueReference:
5375 case clang::Type::RValueReference:
5376 case clang::Type::ObjCObjectPointer: {
5377 CompilerType pointee_clang_type(GetPointeeType(type));
5378
5379 uint32_t num_pointee_children = 0;
5380 if (pointee_clang_type.IsAggregateType())
5381 num_pointee_children =
5382 pointee_clang_type.GetNumChildren(omit_empty_base_classes, exe_ctx);
5383 // If this type points to a simple type, then it has 1 child
5384 if (num_pointee_children == 0)
5385 num_children = 1;
5386 else
5387 num_children = num_pointee_children;
5388 } break;
5389
5390 case clang::Type::Vector:
5391 case clang::Type::ExtVector:
5392 num_children =
5393 llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
5394 break;
5395
5396 case clang::Type::ConstantArray:
5397 num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())
5398 ->getSize()
5399 .getLimitedValue();
5400 break;
5401 case clang::Type::IncompleteArray:
5402 if (auto array_info =
5403 GetDynamicArrayInfo(*this, GetSymbolFile(), qual_type, exe_ctx))
5404 // Only 1-dimensional arrays are supported.
5405 num_children = array_info->element_orders.size()
5406 ? array_info->element_orders.back()
5407 : 0;
5408 break;
5409
5410 case clang::Type::Pointer: {
5411 const clang::PointerType *pointer_type =
5412 llvm::cast<clang::PointerType>(qual_type.getTypePtr());
5413 clang::QualType pointee_type(pointer_type->getPointeeType());
5414 CompilerType pointee_clang_type(GetType(pointee_type));
5415 uint32_t num_pointee_children = 0;
5416 if (pointee_clang_type.IsAggregateType())
5417 num_pointee_children =
5418 pointee_clang_type.GetNumChildren(omit_empty_base_classes, exe_ctx);
5419 if (num_pointee_children == 0) {
5420 // We have a pointer to a pointee type that claims it has no children. We
5421 // will want to look at
5422 num_children = GetNumPointeeChildren(pointee_type);
5423 } else
5424 num_children = num_pointee_children;
5425 } break;
5426
5427 default:
5428 break;
5429 }
5430 return num_children;
5431}
5432
5433CompilerType TypeSystemClang::GetBuiltinTypeByName(ConstString name) {
5434 return GetBasicType(GetBasicTypeEnumeration(name));
5435}
5436
5437lldb::BasicType
5438TypeSystemClang::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
5439 if (type) {
5440 clang::QualType qual_type(GetQualType(type));
5441 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5442 if (type_class == clang::Type::Builtin) {
5443 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5444 case clang::BuiltinType::Void:
5445 return eBasicTypeVoid;
5446 case clang::BuiltinType::Bool:
5447 return eBasicTypeBool;
5448 case clang::BuiltinType::Char_S:
5449 return eBasicTypeSignedChar;
5450 case clang::BuiltinType::Char_U:
5451 return eBasicTypeUnsignedChar;
5452 case clang::BuiltinType::Char16:
5453 return eBasicTypeChar16;
5454 case clang::BuiltinType::Char32:
5455 return eBasicTypeChar32;
5456 case clang::BuiltinType::UChar:
5457 return eBasicTypeUnsignedChar;
5458 case clang::BuiltinType::SChar:
5459 return eBasicTypeSignedChar;
5460 case clang::BuiltinType::WChar_S:
5461 return eBasicTypeSignedWChar;
5462 case clang::BuiltinType::WChar_U:
5463 return eBasicTypeUnsignedWChar;
5464 case clang::BuiltinType::Short:
5465 return eBasicTypeShort;
5466 case clang::BuiltinType::UShort:
5467 return eBasicTypeUnsignedShort;
5468 case clang::BuiltinType::Int:
5469 return eBasicTypeInt;
5470 case clang::BuiltinType::UInt:
5471 return eBasicTypeUnsignedInt;
5472 case clang::BuiltinType::Long:
5473 return eBasicTypeLong;
5474 case clang::BuiltinType::ULong:
5475 return eBasicTypeUnsignedLong;
5476 case clang::BuiltinType::LongLong:
5477 return eBasicTypeLongLong;
5478 case clang::BuiltinType::ULongLong:
5479 return eBasicTypeUnsignedLongLong;
5480 case clang::BuiltinType::Int128:
5481 return eBasicTypeInt128;
5482 case clang::BuiltinType::UInt128:
5483 return eBasicTypeUnsignedInt128;
5484
5485 case clang::BuiltinType::Half:
5486 return eBasicTypeHalf;
5487 case clang::BuiltinType::Float:
5488 return eBasicTypeFloat;
5489 case clang::BuiltinType::Double:
5490 return eBasicTypeDouble;
5491 case clang::BuiltinType::LongDouble:
5492 return eBasicTypeLongDouble;
5493
5494 case clang::BuiltinType::NullPtr:
5495 return eBasicTypeNullPtr;
5496 case clang::BuiltinType::ObjCId:
5497 return eBasicTypeObjCID;
5498 case clang::BuiltinType::ObjCClass:
5499 return eBasicTypeObjCClass;
5500 case clang::BuiltinType::ObjCSel:
5501 return eBasicTypeObjCSel;
5502 default:
5503 return eBasicTypeOther;
5504 }
5505 }
5506 }
5507 return eBasicTypeInvalid;
5508}
5509
5510void TypeSystemClang::ForEachEnumerator(
5511 lldb::opaque_compiler_type_t type,
5512 std::function<bool(const CompilerType &integer_type,
5513 ConstString name,
5514 const llvm::APSInt &value)> const &callback) {
5515 const clang::EnumType *enum_type =
5516 llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
5517 if (enum_type) {
5518 const clang::EnumDecl *enum_decl = enum_type->getDecl();
5519 if (enum_decl) {
5520 CompilerType integer_type = GetType(enum_decl->getIntegerType());
5521
5522 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5523 for (enum_pos = enum_decl->enumerator_begin(),
5524 enum_end_pos = enum_decl->enumerator_end();
5525 enum_pos != enum_end_pos; ++enum_pos) {
5526 ConstString name(enum_pos->getNameAsString().c_str());
5527 if (!callback(integer_type, name, enum_pos->getInitVal()))
5528 break;
5529 }
5530 }
5531 }
5532}
5533
5534#pragma mark Aggregate Types
5535
5536uint32_t TypeSystemClang::GetNumFields(lldb::opaque_compiler_type_t type) {
5537 if (!type)
5538 return 0;
5539
5540 uint32_t count = 0;
5541 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
5542 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5543 switch (type_class) {
5544 case clang::Type::Record:
5545 if (GetCompleteType(type)) {
5546 const clang::RecordType *record_type =
5547 llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
5548 if (record_type) {
5549 clang::RecordDecl *record_decl = record_type->getDecl();
5550 if (record_decl) {
5551 uint32_t field_idx = 0;
5552 clang::RecordDecl::field_iterator field, field_end;
5553 for (field = record_decl->field_begin(),
5554 field_end = record_decl->field_end();
5555 field != field_end; ++field)
5556 ++field_idx;
5557 count = field_idx;
5558 }
5559 }
5560 }
5561 break;
5562
5563 case clang::Type::ObjCObjectPointer: {
5564 const clang::ObjCObjectPointerType *objc_class_type =
5565 qual_type->getAs<clang::ObjCObjectPointerType>();
5566 const clang::ObjCInterfaceType *objc_interface_type =
5567 objc_class_type->getInterfaceType();
5568 if (objc_interface_type &&
5569 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
5570 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
5571 clang::ObjCInterfaceDecl *class_interface_decl =
5572 objc_interface_type->getDecl();
5573 if (class_interface_decl) {
5574 count = class_interface_decl->ivar_size();
5575 }
5576 }
5577 break;
5578 }
5579
5580 case clang::Type::ObjCObject:
5581 case clang::Type::ObjCInterface:
5582 if (GetCompleteType(type)) {
5583 const clang::ObjCObjectType *objc_class_type =
5584 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5585 if (objc_class_type) {
5586 clang::ObjCInterfaceDecl *class_interface_decl =
5587 objc_class_type->getInterface();
5588
5589 if (class_interface_decl)
5590 count = class_interface_decl->ivar_size();
5591 }
5592 }
5593 break;
5594
5595 default:
5596 break;
5597 }
5598 return count;
5599}
5600
5601static lldb::opaque_compiler_type_t
5602GetObjCFieldAtIndex(clang::ASTContext *ast,
5603 clang::ObjCInterfaceDecl *class_interface_decl, size_t idx,
5604 std::string &name, uint64_t *bit_offset_ptr,
5605 uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) {
5606 if (class_interface_decl) {
5607 if (idx < (class_interface_decl->ivar_size())) {
5608 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
5609 ivar_end = class_interface_decl->ivar_end();
5610 uint32_t ivar_idx = 0;
5611
5612 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end;
5613 ++ivar_pos, ++ivar_idx) {
5614 if (ivar_idx == idx) {
5615 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
5616
5617 clang::QualType ivar_qual_type(ivar_decl->getType());
5618
5619 name.assign(ivar_decl->getNameAsString());
5620
5621 if (bit_offset_ptr) {
5622 const clang::ASTRecordLayout &interface_layout =
5623 ast->getASTObjCInterfaceLayout(class_interface_decl);
5624 *bit_offset_ptr = interface_layout.getFieldOffset(ivar_idx);
5625 }
5626
5627 const bool is_bitfield = ivar_pos->isBitField();
5628
5629 if (bitfield_bit_size_ptr) {
5630 *bitfield_bit_size_ptr = 0;
5631
5632 if (is_bitfield && ast) {
5633 clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5634 clang::Expr::EvalResult result;
5635 if (bitfield_bit_size_expr &&
5636 bitfield_bit_size_expr->EvaluateAsInt(result, *ast)) {
5637 llvm::APSInt bitfield_apsint = result.Val.getInt();
5638 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5639 }
5640 }
5641 }
5642 if (is_bitfield_ptr)
5643 *is_bitfield_ptr = is_bitfield;
5644
5645 return ivar_qual_type.getAsOpaquePtr();
5646 }
5647 }
5648 }
5649 }
5650 return nullptr;
5651}
5652
5653CompilerType TypeSystemClang::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
5654 size_t idx, std::string &name,
5655 uint64_t *bit_offset_ptr,
5656 uint32_t *bitfield_bit_size_ptr,
5657 bool *is_bitfield_ptr) {
5658 if (!type)
5659 return CompilerType();
5660
5661 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
5662 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5663 switch (type_class) {
5664 case clang::Type::Record:
5665 if (GetCompleteType(type)) {
5666 const clang::RecordType *record_type =
5667 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5668 const clang::RecordDecl *record_decl = record_type->getDecl();
5669 uint32_t field_idx = 0;
5670 clang::RecordDecl::field_iterator field, field_end;
5671 for (field = record_decl->field_begin(),
5672 field_end = record_decl->field_end();
5673 field != field_end; ++field, ++field_idx) {
5674 if (idx == field_idx) {
5675 // Print the member type if requested
5676 // Print the member name and equal sign
5677 name.assign(field->getNameAsString());
5678
5679 // Figure out the type byte size (field_type_info.first) and
5680 // alignment (field_type_info.second) from the AST context.
5681 if (bit_offset_ptr) {
5682 const clang::ASTRecordLayout &record_layout =
5683 getASTContext().getASTRecordLayout(record_decl);
5684 *bit_offset_ptr = record_layout.getFieldOffset(field_idx);
5685 }
5686
5687 const bool is_bitfield = field->isBitField();
5688
5689 if (bitfield_bit_size_ptr) {
5690 *bitfield_bit_size_ptr = 0;
5691
5692 if (is_bitfield) {
5693 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
5694 clang::Expr::EvalResult result;
5695 if (bitfield_bit_size_expr &&
5696 bitfield_bit_size_expr->EvaluateAsInt(result,
5697 getASTContext())) {
5698 llvm::APSInt bitfield_apsint = result.Val.getInt();
5699 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5700 }
5701 }
5702 }
5703 if (is_bitfield_ptr)
5704 *is_bitfield_ptr = is_bitfield;
5705
5706 return GetType(field->getType());
5707 }
5708 }
5709 }
5710 break;
5711
5712 case clang::Type::ObjCObjectPointer: {
5713 const clang::ObjCObjectPointerType *objc_class_type =
5714 qual_type->getAs<clang::ObjCObjectPointerType>();
5715 const clang::ObjCInterfaceType *objc_interface_type =
5716 objc_class_type->getInterfaceType();
5717 if (objc_interface_type &&
5718 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
5719 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
5720 clang::ObjCInterfaceDecl *class_interface_decl =
5721 objc_interface_type->getDecl();
5722 if (class_interface_decl) {
5723 return CompilerType(
5724 this, GetObjCFieldAtIndex(&getASTContext(), class_interface_decl,
5725 idx, name, bit_offset_ptr,
5726 bitfield_bit_size_ptr, is_bitfield_ptr));
5727 }
5728 }
5729 break;
5730 }
5731
5732 case clang::Type::ObjCObject:
5733 case clang::Type::ObjCInterface:
5734 if (GetCompleteType(type)) {
5735 const clang::ObjCObjectType *objc_class_type =
5736 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5737 assert(objc_class_type)((void)0);
5738 if (objc_class_type) {
5739 clang::ObjCInterfaceDecl *class_interface_decl =
5740 objc_class_type->getInterface();
5741 return CompilerType(
5742 this, GetObjCFieldAtIndex(&getASTContext(), class_interface_decl,
5743 idx, name, bit_offset_ptr,
5744 bitfield_bit_size_ptr, is_bitfield_ptr));
5745 }
5746 }
5747 break;
5748
5749 default:
5750 break;
5751 }
5752 return CompilerType();
5753}
5754
5755uint32_t
5756TypeSystemClang::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) {
5757 uint32_t count = 0;
5758 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5759 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5760 switch (type_class) {
5761 case clang::Type::Record:
5762 if (GetCompleteType(type)) {
5763 const clang::CXXRecordDecl *cxx_record_decl =
5764 qual_type->getAsCXXRecordDecl();
5765 if (cxx_record_decl)
5766 count = cxx_record_decl->getNumBases();
5767 }
5768 break;
5769
5770 case clang::Type::ObjCObjectPointer:
5771 count = GetPointeeType(type).GetNumDirectBaseClasses();
5772 break;
5773
5774 case clang::Type::ObjCObject:
5775 if (GetCompleteType(type)) {
5776 const clang::ObjCObjectType *objc_class_type =
5777 qual_type->getAsObjCQualifiedInterfaceType();
5778 if (objc_class_type) {
5779 clang::ObjCInterfaceDecl *class_interface_decl =
5780 objc_class_type->getInterface();
5781
5782 if (class_interface_decl && class_interface_decl->getSuperClass())
5783 count = 1;
5784 }
5785 }
5786 break;
5787 case clang::Type::ObjCInterface:
5788 if (GetCompleteType(type)) {
5789 const clang::ObjCInterfaceType *objc_interface_type =
5790 qual_type->getAs<clang::ObjCInterfaceType>();
5791 if (objc_interface_type) {
5792 clang::ObjCInterfaceDecl *class_interface_decl =
5793 objc_interface_type->getInterface();
5794
5795 if (class_interface_decl && class_interface_decl->getSuperClass())
5796 count = 1;
5797 }
5798 }
5799 break;
5800
5801 default:
5802 break;
5803 }
5804 return count;
5805}
5806
5807uint32_t
5808TypeSystemClang::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) {
5809 uint32_t count = 0;
5810 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5811 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5812 switch (type_class) {
5813 case clang::Type::Record:
5814 if (GetCompleteType(type)) {
5815 const clang::CXXRecordDecl *cxx_record_decl =
5816 qual_type->getAsCXXRecordDecl();
5817 if (cxx_record_decl)
5818 count = cxx_record_decl->getNumVBases();
5819 }
5820 break;
5821
5822 default:
5823 break;
5824 }
5825 return count;
5826}
5827
5828CompilerType TypeSystemClang::GetDirectBaseClassAtIndex(
5829 lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
5830 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5831 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5832 switch (type_class) {
5833 case clang::Type::Record:
5834 if (GetCompleteType(type)) {
5835 const clang::CXXRecordDecl *cxx_record_decl =
5836 qual_type->getAsCXXRecordDecl();
5837 if (cxx_record_decl) {
5838 uint32_t curr_idx = 0;
5839 clang::CXXRecordDecl::base_class_const_iterator base_class,
5840 base_class_end;
5841 for (base_class = cxx_record_decl->bases_begin(),
5842 base_class_end = cxx_record_decl->bases_end();
5843 base_class != base_class_end; ++base_class, ++curr_idx) {
5844 if (curr_idx == idx) {
5845 if (bit_offset_ptr) {
5846 const clang::ASTRecordLayout &record_layout =
5847 getASTContext().getASTRecordLayout(cxx_record_decl);
5848 const clang::CXXRecordDecl *base_class_decl =
5849 llvm::cast<clang::CXXRecordDecl>(
5850 base_class->getType()
5851 ->getAs<clang::RecordType>()
5852 ->getDecl());
5853 if (base_class->isVirtual())
5854 *bit_offset_ptr =
5855 record_layout.getVBaseClassOffset(base_class_decl)
5856 .getQuantity() *
5857 8;
5858 else
5859 *bit_offset_ptr =
5860 record_layout.getBaseClassOffset(base_class_decl)
5861 .getQuantity() *
5862 8;
5863 }
5864 return GetType(base_class->getType());
5865 }
5866 }
5867 }
5868 }
5869 break;
5870
5871 case clang::Type::ObjCObjectPointer:
5872 return GetPointeeType(type).GetDirectBaseClassAtIndex(idx, bit_offset_ptr);
5873
5874 case clang::Type::ObjCObject:
5875 if (idx == 0 && GetCompleteType(type)) {
5876 const clang::ObjCObjectType *objc_class_type =
5877 qual_type->getAsObjCQualifiedInterfaceType();
5878 if (objc_class_type) {
5879 clang::ObjCInterfaceDecl *class_interface_decl =
5880 objc_class_type->getInterface();
5881
5882 if (class_interface_decl) {
5883 clang::ObjCInterfaceDecl *superclass_interface_decl =
5884 class_interface_decl->getSuperClass();
5885 if (superclass_interface_decl) {
5886 if (bit_offset_ptr)
5887 *bit_offset_ptr = 0;
5888 return GetType(getASTContext().getObjCInterfaceType(
5889 superclass_interface_decl));
5890 }
5891 }
5892 }
5893 }
5894 break;
5895 case clang::Type::ObjCInterface:
5896 if (idx == 0 && GetCompleteType(type)) {
5897 const clang::ObjCObjectType *objc_interface_type =
5898 qual_type->getAs<clang::ObjCInterfaceType>();
5899 if (objc_interface_type) {
5900 clang::ObjCInterfaceDecl *class_interface_decl =
5901 objc_interface_type->getInterface();
5902
5903 if (class_interface_decl) {
5904 clang::ObjCInterfaceDecl *superclass_interface_decl =
5905 class_interface_decl->getSuperClass();
5906 if (superclass_interface_decl) {
5907 if (bit_offset_ptr)
5908 *bit_offset_ptr = 0;
5909 return GetType(getASTContext().getObjCInterfaceType(
5910 superclass_interface_decl));
5911 }
5912 }
5913 }
5914 }
5915 break;
5916
5917 default:
5918 break;
5919 }
5920 return CompilerType();
5921}
5922
5923CompilerType TypeSystemClang::GetVirtualBaseClassAtIndex(
5924 lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
5925 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5926 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5927 switch (type_class) {
5928 case clang::Type::Record:
5929 if (GetCompleteType(type)) {
5930 const clang::CXXRecordDecl *cxx_record_decl =
5931 qual_type->getAsCXXRecordDecl();
5932 if (cxx_record_decl) {
5933 uint32_t curr_idx = 0;
5934 clang::CXXRecordDecl::base_class_const_iterator base_class,
5935 base_class_end;
5936 for (base_class = cxx_record_decl->vbases_begin(),
5937 base_class_end = cxx_record_decl->vbases_end();
5938 base_class != base_class_end; ++base_class, ++curr_idx) {
5939 if (curr_idx == idx) {
5940 if (bit_offset_ptr) {
5941 const clang::ASTRecordLayout &record_layout =
5942 getASTContext().getASTRecordLayout(cxx_record_decl);
5943 const clang::CXXRecordDecl *base_class_decl =
5944 llvm::cast<clang::CXXRecordDecl>(
5945 base_class->getType()
5946 ->getAs<clang::RecordType>()
5947 ->getDecl());
5948 *bit_offset_ptr =
5949 record_layout.getVBaseClassOffset(base_class_decl)
5950 .getQuantity() *
5951 8;
5952 }
5953 return GetType(base_class->getType());
5954 }
5955 }
5956 }
5957 }
5958 break;
5959
5960 default:
5961 break;
5962 }
5963 return CompilerType();
5964}
5965
5966// If a pointer to a pointee type (the clang_type arg) says that it has no
5967// children, then we either need to trust it, or override it and return a
5968// different result. For example, an "int *" has one child that is an integer,
5969// but a function pointer doesn't have any children. Likewise if a Record type
5970// claims it has no children, then there really is nothing to show.
5971uint32_t TypeSystemClang::GetNumPointeeChildren(clang::QualType type) {
5972 if (type.isNull())
5973 return 0;
5974
5975 clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
5976 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5977 switch (type_class) {
5978 case clang::Type::Builtin:
5979 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5980 case clang::BuiltinType::UnknownAny:
5981 case clang::BuiltinType::Void:
5982 case clang::BuiltinType::NullPtr:
5983 case clang::BuiltinType::OCLEvent:
5984 case clang::BuiltinType::OCLImage1dRO:
5985 case clang::BuiltinType::OCLImage1dWO:
5986 case clang::BuiltinType::OCLImage1dRW:
5987 case clang::BuiltinType::OCLImage1dArrayRO:
5988 case clang::BuiltinType::OCLImage1dArrayWO:
5989 case clang::BuiltinType::OCLImage1dArrayRW:
5990 case clang::BuiltinType::OCLImage1dBufferRO:
5991 case clang::BuiltinType::OCLImage1dBufferWO:
5992 case clang::BuiltinType::OCLImage1dBufferRW:
5993 case clang::BuiltinType::OCLImage2dRO:
5994 case clang::BuiltinType::OCLImage2dWO:
5995 case clang::BuiltinType::OCLImage2dRW:
5996 case clang::BuiltinType::OCLImage2dArrayRO:
5997 case clang::BuiltinType::OCLImage2dArrayWO:
5998 case clang::BuiltinType::OCLImage2dArrayRW:
5999 case clang::BuiltinType::OCLImage3dRO:
6000 case clang::BuiltinType::OCLImage3dWO:
6001 case clang::BuiltinType::OCLImage3dRW:
6002 case clang::BuiltinType::OCLSampler:
6003 return 0;
6004 case clang::BuiltinType::Bool:
6005 case clang::BuiltinType::Char_U:
6006 case clang::BuiltinType::UChar:
6007 case clang::BuiltinType::WChar_U:
6008 case clang::BuiltinType::Char16:
6009 case clang::BuiltinType::Char32:
6010 case clang::BuiltinType::UShort:
6011 case clang::BuiltinType::UInt:
6012 case clang::BuiltinType::ULong:
6013 case clang::BuiltinType::ULongLong:
6014 case clang::BuiltinType::UInt128:
6015 case clang::BuiltinType::Char_S:
6016 case clang::BuiltinType::SChar:
6017 case clang::BuiltinType::WChar_S:
6018 case clang::BuiltinType::Short:
6019 case clang::BuiltinType::Int:
6020 case clang::BuiltinType::Long:
6021 case clang::BuiltinType::LongLong:
6022 case clang::BuiltinType::Int128:
6023 case clang::BuiltinType::Float:
6024 case clang::BuiltinType::Double:
6025 case clang::BuiltinType::LongDouble:
6026 case clang::BuiltinType::Dependent:
6027 case clang::BuiltinType::Overload:
6028 case clang::BuiltinType::ObjCId:
6029 case clang::BuiltinType::ObjCClass:
6030 case clang::BuiltinType::ObjCSel:
6031 case clang::BuiltinType::BoundMember:
6032 case clang::BuiltinType::Half:
6033 case clang::BuiltinType::ARCUnbridgedCast:
6034 case clang::BuiltinType::PseudoObject:
6035 case clang::BuiltinType::BuiltinFn:
6036 case clang::BuiltinType::OMPArraySection:
6037 return 1;
6038 default:
6039 return 0;
6040 }
6041 break;
6042
6043 case clang::Type::Complex:
6044 return 1;
6045 case clang::Type::Pointer:
6046 return 1;
6047 case clang::Type::BlockPointer:
6048 return 0; // If block pointers don't have debug info, then no children for
6049 // them
6050 case clang::Type::LValueReference:
6051 return 1;
6052 case clang::Type::RValueReference:
6053 return 1;
6054 case clang::Type::MemberPointer:
6055 return 0;
6056 case clang::Type::ConstantArray:
6057 return 0;
6058 case clang::Type::IncompleteArray:
6059 return 0;
6060 case clang::Type::VariableArray:
6061 return 0;
6062 case clang::Type::DependentSizedArray:
6063 return 0;
6064 case clang::Type::DependentSizedExtVector:
6065 return 0;
6066 case clang::Type::Vector:
6067 return 0;
6068 case clang::Type::ExtVector:
6069 return 0;
6070 case clang::Type::FunctionProto:
6071 return 0; // When we function pointers, they have no children...
6072 case clang::Type::FunctionNoProto:
6073 return 0; // When we function pointers, they have no children...
6074 case clang::Type::UnresolvedUsing:
6075 return 0;
6076 case clang::Type::Record:
6077 return 0;
6078 case clang::Type::Enum:
6079 return 1;
6080 case clang::Type::TemplateTypeParm:
6081 return 1;
6082 case clang::Type::SubstTemplateTypeParm:
6083 return 1;
6084 case clang::Type::TemplateSpecialization:
6085 return 1;
6086 case clang::Type::InjectedClassName:
6087 return 0;
6088 case clang::Type::DependentName:
6089 return 1;
6090 case clang::Type::DependentTemplateSpecialization:
6091 return 1;
6092 case clang::Type::ObjCObject:
6093 return 0;
6094 case clang::Type::ObjCInterface:
6095 return 0;
6096 case clang::Type::ObjCObjectPointer:
6097 return 1;
6098 default:
6099 break;
6100 }
6101 return 0;
6102}
6103
6104CompilerType TypeSystemClang::GetChildCompilerTypeAtIndex(
6105 lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
6106 bool transparent_pointers, bool omit_empty_base_classes,
6107 bool ignore_array_bounds, std::string &child_name,
6108 uint32_t &child_byte_size, int32_t &child_byte_offset,
6109 uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
6110 bool &child_is_base_class, bool &child_is_deref_of_parent,
6111 ValueObject *valobj, uint64_t &language_flags) {
6112 if (!type)
6113 return CompilerType();
6114
6115 auto get_exe_scope = [&exe_ctx]() {
6116 return exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
6117 };
6118
6119 clang::QualType parent_qual_type(
6120 RemoveWrappingTypes(GetCanonicalQualType(type)));
6121 const clang::Type::TypeClass parent_type_class =
6122 parent_qual_type->getTypeClass();
6123 child_bitfield_bit_size = 0;
6124 child_bitfield_bit_offset = 0;
6125 child_is_base_class = false;
6126 language_flags = 0;
6127
6128 const bool idx_is_valid =
6129 idx < GetNumChildren(type, omit_empty_base_classes, exe_ctx);
6130 int32_t bit_offset;
6131 switch (parent_type_class) {
6132 case clang::Type::Builtin:
6133 if (idx_is_valid) {
6134 switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind()) {
6135 case clang::BuiltinType::ObjCId:
6136 case clang::BuiltinType::ObjCClass:
6137 child_name = "isa";
6138 child_byte_size =
6139 getASTContext().getTypeSize(getASTContext().ObjCBuiltinClassTy) /
6140 CHAR_BIT8;
6141 return GetType(getASTContext().ObjCBuiltinClassTy);
6142
6143 default:
6144 break;
6145 }
6146 }
6147 break;
6148
6149 case clang::Type::Record:
6150 if (idx_is_valid && GetCompleteType(type)) {
6151 const clang::RecordType *record_type =
6152 llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr());
6153 const clang::RecordDecl *record_decl = record_type->getDecl();
6154 assert(record_decl)((void)0);
6155 const clang::ASTRecordLayout &record_layout =
6156 getASTContext().getASTRecordLayout(record_decl);
6157 uint32_t child_idx = 0;
6158
6159 const clang::CXXRecordDecl *cxx_record_decl =
6160 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6161 if (cxx_record_decl) {
6162 // We might have base classes to print out first
6163 clang::CXXRecordDecl::base_class_const_iterator base_class,
6164 base_class_end;
6165 for (base_class = cxx_record_decl->bases_begin(),
6166 base_class_end = cxx_record_decl->bases_end();
6167 base_class != base_class_end; ++base_class) {
6168 const clang::CXXRecordDecl *base_class_decl = nullptr;
6169
6170 // Skip empty base classes
6171 if (omit_empty_base_classes) {
6172 base_class_decl = llvm::cast<clang::CXXRecordDecl>(
6173 base_class->getType()->getAs<clang::RecordType>()->getDecl());
6174 if (!TypeSystemClang::RecordHasFields(base_class_decl))
6175 continue;
6176 }
6177
6178 if (idx == child_idx) {
6179 if (base_class_decl == nullptr)
6180 base_class_decl = llvm::cast<clang::CXXRecordDecl>(
6181 base_class->getType()->getAs<clang::RecordType>()->getDecl());
6182
6183 if (base_class->isVirtual()) {
6184 bool handled = false;
6185 if (valobj) {
6186 clang::VTableContextBase *vtable_ctx =
6187 getASTContext().getVTableContext();
6188 if (vtable_ctx)
6189 handled = GetVBaseBitOffset(*vtable_ctx, *valobj,
6190 record_layout, cxx_record_decl,
6191 base_class_decl, bit_offset);
6192 }
6193 if (!handled)
6194 bit_offset = record_layout.getVBaseClassOffset(base_class_decl)
6195 .getQuantity() *
6196 8;
6197 } else
6198 bit_offset = record_layout.getBaseClassOffset(base_class_decl)
6199 .getQuantity() *
6200 8;
6201
6202 // Base classes should be a multiple of 8 bits in size
6203 child_byte_offset = bit_offset / 8;
6204 CompilerType base_class_clang_type = GetType(base_class->getType());
6205 child_name = base_class_clang_type.GetTypeName().AsCString("");
6206 Optional<uint64_t> size =
6207 base_class_clang_type.GetBitSize(get_exe_scope());
6208 if (!size)
6209 return {};
6210 uint64_t base_class_clang_type_bit_size = *size;
6211
6212 // Base classes bit sizes should be a multiple of 8 bits in size
6213 assert(base_class_clang_type_bit_size % 8 == 0)((void)0);
6214 child_byte_size = base_class_clang_type_bit_size / 8;
6215 child_is_base_class = true;
6216 return base_class_clang_type;
6217 }
6218 // We don't increment the child index in the for loop since we might
6219 // be skipping empty base classes
6220 ++child_idx;
6221 }
6222 }
6223 // Make sure index is in range...
6224 uint32_t field_idx = 0;
6225 clang::RecordDecl::field_iterator field, field_end;
6226 for (field = record_decl->field_begin(),
6227 field_end = record_decl->field_end();
6228 field != field_end; ++field, ++field_idx, ++child_idx) {
6229 if (idx == child_idx) {
6230 // Print the member type if requested
6231 // Print the member name and equal sign
6232 child_name.assign(field->getNameAsString());
6233
6234 // Figure out the type byte size (field_type_info.first) and
6235 // alignment (field_type_info.second) from the AST context.
6236 CompilerType field_clang_type = GetType(field->getType());
6237 assert(field_idx < record_layout.getFieldCount())((void)0);
6238 Optional<uint64_t> size =
6239 field_clang_type.GetByteSize(get_exe_scope());
6240 if (!size)
6241 return {};
6242 child_byte_size = *size;
6243 const uint32_t child_bit_size = child_byte_size * 8;
6244
6245 // Figure out the field offset within the current struct/union/class
6246 // type
6247 bit_offset = record_layout.getFieldOffset(field_idx);
6248 if (FieldIsBitfield(*field, child_bitfield_bit_size)) {
6249 child_bitfield_bit_offset = bit_offset % child_bit_size;
6250 const uint32_t child_bit_offset =
6251 bit_offset - child_bitfield_bit_offset;
6252 child_byte_offset = child_bit_offset / 8;
6253 } else {
6254 child_byte_offset = bit_offset / 8;
6255 }
6256
6257 return field_clang_type;
6258 }
6259 }
6260 }
6261 break;
6262
6263 case clang::Type::ObjCObject:
6264 case clang::Type::ObjCInterface:
6265 if (idx_is_valid && GetCompleteType(type)) {
6266 const clang::ObjCObjectType *objc_class_type =
6267 llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr());
6268 assert(objc_class_type)((void)0);
6269 if (objc_class_type) {
6270 uint32_t child_idx = 0;
6271 clang::ObjCInterfaceDecl *class_interface_decl =
6272 objc_class_type->getInterface();
6273
6274 if (class_interface_decl) {
6275
6276 const clang::ASTRecordLayout &interface_layout =
6277 getASTContext().getASTObjCInterfaceLayout(class_interface_decl);
6278 clang::ObjCInterfaceDecl *superclass_interface_decl =
6279 class_interface_decl->getSuperClass();
6280 if (superclass_interface_decl) {
6281 if (omit_empty_base_classes) {
6282 CompilerType base_class_clang_type =
6283 GetType(getASTContext().getObjCInterfaceType(
6284 superclass_interface_decl));
6285 if (base_class_clang_type.GetNumChildren(omit_empty_base_classes,
6286 exe_ctx) > 0) {
6287 if (idx == 0) {
6288 clang::QualType ivar_qual_type(
6289 getASTContext().getObjCInterfaceType(
6290 superclass_interface_decl));
6291
6292 child_name.assign(
6293 superclass_interface_decl->getNameAsString());
6294
6295 clang::TypeInfo ivar_type_info =
6296 getASTContext().getTypeInfo(ivar_qual_type.getTypePtr());
6297
6298 child_byte_size = ivar_type_info.Width / 8;
6299 child_byte_offset = 0;
6300 child_is_base_class = true;
6301
6302 return GetType(ivar_qual_type);
6303 }
6304
6305 ++child_idx;
6306 }
6307 } else
6308 ++child_idx;
6309 }
6310
6311 const uint32_t superclass_idx = child_idx;
6312
6313 if (idx < (child_idx + class_interface_decl->ivar_size())) {
6314 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
6315 ivar_end = class_interface_decl->ivar_end();
6316
6317 for (ivar_pos = class_interface_decl->ivar_begin();
6318 ivar_pos != ivar_end; ++ivar_pos) {
6319 if (child_idx == idx) {
6320 clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
6321
6322 clang::QualType ivar_qual_type(ivar_decl->getType());
6323
6324 child_name.assign(ivar_decl->getNameAsString());
6325
6326 clang::TypeInfo ivar_type_info =
6327 getASTContext().getTypeInfo(ivar_qual_type.getTypePtr());
6328
6329 child_byte_size = ivar_type_info.Width / 8;
6330
6331 // Figure out the field offset within the current
6332 // struct/union/class type For ObjC objects, we can't trust the
6333 // bit offset we get from the Clang AST, since that doesn't
6334 // account for the space taken up by unbacked properties, or
6335 // from the changing size of base classes that are newer than
6336 // this class. So if we have a process around that we can ask
6337 // about this object, do so.
6338 child_byte_offset = LLDB_INVALID_IVAR_OFFSET0xffffffffU;
6339 Process *process = nullptr;
6340 if (exe_ctx)
6341 process = exe_ctx->GetProcessPtr();
6342 if (process) {
6343 ObjCLanguageRuntime *objc_runtime =
6344 ObjCLanguageRuntime::Get(*process);
6345 if (objc_runtime != nullptr) {
6346 CompilerType parent_ast_type = GetType(parent_qual_type);
6347 child_byte_offset = objc_runtime->GetByteOffsetForIvar(
6348 parent_ast_type, ivar_decl->getNameAsString().c_str());
6349 }
6350 }
6351
6352 // Setting this to INT32_MAX to make sure we don't compute it
6353 // twice...
6354 bit_offset = INT32_MAX0x7fffffff;
6355
6356 if (child_byte_offset ==
6357 static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET0xffffffffU)) {
6358 bit_offset = interface_layout.getFieldOffset(child_idx -
6359 superclass_idx);
6360 child_byte_offset = bit_offset / 8;
6361 }
6362
6363 // Note, the ObjC Ivar Byte offset is just that, it doesn't
6364 // account for the bit offset of a bitfield within its
6365 // containing object. So regardless of where we get the byte
6366 // offset from, we still need to get the bit offset for
6367 // bitfields from the layout.
6368
6369 if (FieldIsBitfield(ivar_decl, child_bitfield_bit_size)) {
6370 if (bit_offset == INT32_MAX0x7fffffff)
6371 bit_offset = interface_layout.getFieldOffset(
6372 child_idx - superclass_idx);
6373
6374 child_bitfield_bit_offset = bit_offset % 8;
6375 }
6376 return GetType(ivar_qual_type);
6377 }
6378 ++child_idx;
6379 }
6380 }
6381 }
6382 }
6383 }
6384 break;
6385
6386 case clang::Type::ObjCObjectPointer:
6387 if (idx_is_valid) {
6388 CompilerType pointee_clang_type(GetPointeeType(type));
6389
6390 if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
6391 child_is_deref_of_parent = false;
6392 bool tmp_child_is_deref_of_parent = false;
6393 return pointee_clang_type.GetChildCompilerTypeAtIndex(
6394 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6395 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6396 child_bitfield_bit_size, child_bitfield_bit_offset,
6397 child_is_base_class, tmp_child_is_deref_of_parent, valobj,
6398 language_flags);
6399 } else {
6400 child_is_deref_of_parent = true;
6401 const char *parent_name =
6402 valobj ? valobj->GetName().GetCString() : nullptr;
6403 if (parent_name) {
6404 child_name.assign(1, '*');
6405 child_name += parent_name;
6406 }
6407
6408 // We have a pointer to an simple type
6409 if (idx == 0 && pointee_clang_type.GetCompleteType()) {
6410 if (Optional<uint64_t> size =
6411 pointee_clang_type.GetByteSize(get_exe_scope())) {
6412 child_byte_size = *size;
6413 child_byte_offset = 0;
6414 return pointee_clang_type;
6415 }
6416 }
6417 }
6418 }
6419 break;
6420
6421 case clang::Type::Vector:
6422 case clang::Type::ExtVector:
6423 if (idx_is_valid) {
6424 const clang::VectorType *array =
6425 llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr());
6426 if (array) {
6427 CompilerType element_type = GetType(array->getElementType());
6428 if (element_type.GetCompleteType()) {
6429 char element_name[64];
6430 ::snprintf(element_name, sizeof(element_name), "[%" PRIu64"llu" "]",
6431 static_cast<uint64_t>(idx));
6432 child_name.assign(element_name);
6433 if (Optional<uint64_t> size =
6434 element_type.GetByteSize(get_exe_scope())) {
6435 child_byte_size = *size;
6436 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
6437 return element_type;
6438 }
6439 }
6440 }
6441 }
6442 break;
6443
6444 case clang::Type::ConstantArray:
6445 case clang::Type::IncompleteArray:
6446 if (ignore_array_bounds || idx_is_valid) {
6447 const clang::ArrayType *array = GetQualType(type)->getAsArrayTypeUnsafe();
6448 if (array) {
6449 CompilerType element_type = GetType(array->getElementType());
6450 if (element_type.GetCompleteType()) {
6451 child_name = std::string(llvm::formatv("[{0}]", idx));
6452 if (Optional<uint64_t> size =
6453 element_type.GetByteSize(get_exe_scope())) {
6454 child_byte_size = *size;
6455 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
6456 return element_type;
6457 }
6458 }
6459 }
6460 }
6461 break;
6462
6463 case clang::Type::Pointer: {
6464 CompilerType pointee_clang_type(GetPointeeType(type));
6465
6466 // Don't dereference "void *" pointers
6467 if (pointee_clang_type.IsVoidType())
6468 return CompilerType();
6469
6470 if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
6471 child_is_deref_of_parent = false;
6472 bool tmp_child_is_deref_of_parent = false;
6473 return pointee_clang_type.GetChildCompilerTypeAtIndex(
6474 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6475 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6476 child_bitfield_bit_size, child_bitfield_bit_offset,
6477 child_is_base_class, tmp_child_is_deref_of_parent, valobj,
6478 language_flags);
6479 } else {
6480 child_is_deref_of_parent = true;
6481
6482 const char *parent_name =
6483 valobj ? valobj->GetName().GetCString() : nullptr;
6484 if (parent_name) {
6485 child_name.assign(1, '*');
6486 child_name += parent_name;
6487 }
6488
6489 // We have a pointer to an simple type
6490 if (idx == 0) {
6491 if (Optional<uint64_t> size =
6492 pointee_clang_type.GetByteSize(get_exe_scope())) {
6493 child_byte_size = *size;
6494 child_byte_offset = 0;
6495 return pointee_clang_type;
6496 }
6497 }
6498 }
6499 break;
6500 }
6501
6502 case clang::Type::LValueReference:
6503 case clang::Type::RValueReference:
6504 if (idx_is_valid) {
6505 const clang::ReferenceType *reference_type =
6506 llvm::cast<clang::ReferenceType>(GetQualType(type).getTypePtr());
6507 CompilerType pointee_clang_type =
6508 GetType(reference_type->getPointeeType());
6509 if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
6510 child_is_deref_of_parent = false;
6511 bool tmp_child_is_deref_of_parent = false;
6512 return pointee_clang_type.GetChildCompilerTypeAtIndex(
6513 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6514 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6515 child_bitfield_bit_size, child_bitfield_bit_offset,
6516 child_is_base_class, tmp_child_is_deref_of_parent, valobj,
6517 language_flags);
6518 } else {
6519 const char *parent_name =
6520 valobj ? valobj->GetName().GetCString() : nullptr;
6521 if (parent_name) {
6522 child_name.assign(1, '&');
6523 child_name += parent_name;
6524 }
6525
6526 // We have a pointer to an simple type
6527 if (idx == 0) {
6528 if (Optional<uint64_t> size =
6529 pointee_clang_type.GetByteSize(get_exe_scope())) {
6530 child_byte_size = *size;
6531 child_byte_offset = 0;
6532 return pointee_clang_type;
6533 }
6534 }
6535 }
6536 }
6537 break;
6538
6539 default:
6540 break;
6541 }
6542 return CompilerType();
6543}
6544
6545static uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl,
6546 const clang::CXXBaseSpecifier *base_spec,
6547 bool omit_empty_base_classes) {
6548 uint32_t child_idx = 0;
6549
6550 const clang::CXXRecordDecl *cxx_record_decl =
6551 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6552
6553 if (cxx_record_decl) {
6554 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
6555 for (base_class = cxx_record_decl->bases_begin(),
6556 base_class_end = cxx_record_decl->bases_end();
6557 base_class != base_class_end; ++base_class) {
6558 if (omit_empty_base_classes) {
6559 if (BaseSpecifierIsEmpty(base_class))
6560 continue;
6561 }
6562
6563 if (base_class == base_spec)
6564 return child_idx;
6565 ++child_idx;
6566 }
6567 }
6568
6569 return UINT32_MAX0xffffffffU;
6570}
6571
6572static uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl,
6573 clang::NamedDecl *canonical_decl,
6574 bool omit_empty_base_classes) {
6575 uint32_t child_idx = TypeSystemClang::GetNumBaseClasses(
6576 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
6577 omit_empty_base_classes);
6578
6579 clang::RecordDecl::field_iterator field, field_end;
6580 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
6581 field != field_end; ++field, ++child_idx) {
6582 if (field->getCanonicalDecl() == canonical_decl)
6583 return child_idx;
6584 }
6585
6586 return UINT32_MAX0xffffffffU;
6587}
6588
6589// Look for a child member (doesn't include base classes, but it does include
6590// their members) in the type hierarchy. Returns an index path into
6591// "clang_type" on how to reach the appropriate member.
6592//
6593// class A
6594// {
6595// public:
6596// int m_a;
6597// int m_b;
6598// };
6599//
6600// class B
6601// {
6602// };
6603//
6604// class C :
6605// public B,
6606// public A
6607// {
6608// };
6609//
6610// If we have a clang type that describes "class C", and we wanted to looked
6611// "m_b" in it:
6612//
6613// With omit_empty_base_classes == false we would get an integer array back
6614// with: { 1, 1 } The first index 1 is the child index for "class A" within
6615// class C The second index 1 is the child index for "m_b" within class A
6616//
6617// With omit_empty_base_classes == true we would get an integer array back
6618// with: { 0, 1 } The first index 0 is the child index for "class A" within
6619// class C (since class B doesn't have any members it doesn't count) The second
6620// index 1 is the child index for "m_b" within class A
6621
6622size_t TypeSystemClang::GetIndexOfChildMemberWithName(
6623 lldb::opaque_compiler_type_t type, const char *name,
6624 bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
6625 if (type && name && name[0]) {
6626 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
6627 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6628 switch (type_class) {
6629 case clang::Type::Record:
6630 if (GetCompleteType(type)) {
6631 const clang::RecordType *record_type =
6632 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
6633 const clang::RecordDecl *record_decl = record_type->getDecl();
6634
6635 assert(record_decl)((void)0);
6636 uint32_t child_idx = 0;
6637
6638 const clang::CXXRecordDecl *cxx_record_decl =
6639 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6640
6641 // Try and find a field that matches NAME
6642 clang::RecordDecl::field_iterator field, field_end;
6643 llvm::StringRef name_sref(name);
6644 for (field = record_decl->field_begin(),
6645 field_end = record_decl->field_end();
6646 field != field_end; ++field, ++child_idx) {
6647 llvm::StringRef field_name = field->getName();
6648 if (field_name.empty()) {
6649 CompilerType field_type = GetType(field->getType());
6650 child_indexes.push_back(child_idx);
6651 if (field_type.GetIndexOfChildMemberWithName(
6652 name, omit_empty_base_classes, child_indexes))
6653 return child_indexes.size();
6654 child_indexes.pop_back();
6655
6656 } else if (field_name.equals(name_sref)) {
6657 // We have to add on the number of base classes to this index!
6658 child_indexes.push_back(
6659 child_idx + TypeSystemClang::GetNumBaseClasses(
6660 cxx_record_decl, omit_empty_base_classes));
6661 return child_indexes.size();
6662 }
6663 }
6664
6665 if (cxx_record_decl) {
6666 const clang::RecordDecl *parent_record_decl = cxx_record_decl;
6667
6668 // Didn't find things easily, lets let clang do its thang...
6669 clang::IdentifierInfo &ident_ref =
6670 getASTContext().Idents.get(name_sref);
6671 clang::DeclarationName decl_name(&ident_ref);
6672
6673 clang::CXXBasePaths paths;
6674 if (cxx_record_decl->lookupInBases(
6675 [decl_name](const clang::CXXBaseSpecifier *specifier,
6676 clang::CXXBasePath &path) {
6677 CXXRecordDecl *record =
6678 specifier->getType()->getAsCXXRecordDecl();
6679 auto r = record->lookup(decl_name);
6680 path.Decls = r.begin();
6681 return !r.empty();
6682 },
6683 paths)) {
6684 clang::CXXBasePaths::const_paths_iterator path,
6685 path_end = paths.end();
6686 for (path = paths.begin(); path != path_end; ++path) {
6687 const size_t num_path_elements = path->size();
6688 for (size_t e = 0; e < num_path_elements; ++e) {
6689 clang::CXXBasePathElement elem = (*path)[e];
6690
6691 child_idx = GetIndexForRecordBase(parent_record_decl, elem.Base,
6692 omit_empty_base_classes);
6693 if (child_idx == UINT32_MAX0xffffffffU) {
6694 child_indexes.clear();
6695 return 0;
6696 } else {
6697 child_indexes.push_back(child_idx);
6698 parent_record_decl = llvm::cast<clang::RecordDecl>(
6699 elem.Base->getType()
6700 ->getAs<clang::RecordType>()
6701 ->getDecl());
6702 }
6703 }
6704 for (clang::DeclContext::lookup_iterator I = path->Decls, E;
6705 I != E; ++I) {
6706 child_idx = GetIndexForRecordChild(
6707 parent_record_decl, *I, omit_empty_base_classes);
6708 if (child_idx == UINT32_MAX0xffffffffU) {
6709 child_indexes.clear();
6710 return 0;
6711 } else {
6712 child_indexes.push_back(child_idx);
6713 }
6714 }
6715 }
6716 return child_indexes.size();
6717 }
6718 }
6719 }
6720 break;
6721
6722 case clang::Type::ObjCObject:
6723 case clang::Type::ObjCInterface:
6724 if (GetCompleteType(type)) {
6725 llvm::StringRef name_sref(name);
6726 const clang::ObjCObjectType *objc_class_type =
6727 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
6728 assert(objc_class_type)((void)0);
6729 if (objc_class_type) {
6730 uint32_t child_idx = 0;
6731 clang::ObjCInterfaceDecl *class_interface_decl =
6732 objc_class_type->getInterface();
6733
6734 if (class_interface_decl) {
6735 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
6736 ivar_end = class_interface_decl->ivar_end();
6737 clang::ObjCInterfaceDecl *superclass_interface_decl =
6738 class_interface_decl->getSuperClass();
6739
6740 for (ivar_pos = class_interface_decl->ivar_begin();
6741 ivar_pos != ivar_end; ++ivar_pos, ++child_idx) {
6742 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
6743
6744 if (ivar_decl->getName().equals(name_sref)) {
6745 if ((!omit_empty_base_classes && superclass_interface_decl) ||
6746 (omit_empty_base_classes &&
6747 ObjCDeclHasIVars(superclass_interface_decl, true)))
6748 ++child_idx;
6749
6750 child_indexes.push_back(child_idx);
6751 return child_indexes.size();
6752 }
6753 }
6754
6755 if (superclass_interface_decl) {
6756 // The super class index is always zero for ObjC classes, so we
6757 // push it onto the child indexes in case we find an ivar in our
6758 // superclass...
6759 child_indexes.push_back(0);
6760
6761 CompilerType superclass_clang_type =
6762 GetType(getASTContext().getObjCInterfaceType(
6763 superclass_interface_decl));
6764 if (superclass_clang_type.GetIndexOfChildMemberWithName(
6765 name, omit_empty_base_classes, child_indexes)) {
6766 // We did find an ivar in a superclass so just return the
6767 // results!
6768 return child_indexes.size();
6769 }
6770
6771 // We didn't find an ivar matching "name" in our superclass, pop
6772 // the superclass zero index that we pushed on above.
6773 child_indexes.pop_back();
6774 }
6775 }
6776 }
6777 }
6778 break;
6779
6780 case clang::Type::ObjCObjectPointer: {
6781 CompilerType objc_object_clang_type = GetType(
6782 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
6783 ->getPointeeType());
6784 return objc_object_clang_type.GetIndexOfChildMemberWithName(
6785 name, omit_empty_base_classes, child_indexes);
6786 } break;
6787
6788 case clang::Type::ConstantArray: {
6789 // const clang::ConstantArrayType *array =
6790 // llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
6791 // const uint64_t element_count =
6792 // array->getSize().getLimitedValue();
6793 //
6794 // if (idx < element_count)
6795 // {
6796 // std::pair<uint64_t, unsigned> field_type_info =
6797 // ast->getTypeInfo(array->getElementType());
6798 //
6799 // char element_name[32];
6800 // ::snprintf (element_name, sizeof (element_name),
6801 // "%s[%u]", parent_name ? parent_name : "", idx);
6802 //
6803 // child_name.assign(element_name);
6804 // assert(field_type_info.first % 8 == 0);
6805 // child_byte_size = field_type_info.first / 8;
6806 // child_byte_offset = idx * child_byte_size;
6807 // return array->getElementType().getAsOpaquePtr();
6808 // }
6809 } break;
6810
6811 // case clang::Type::MemberPointerType:
6812 // {
6813 // MemberPointerType *mem_ptr_type =
6814 // llvm::cast<MemberPointerType>(qual_type.getTypePtr());
6815 // clang::QualType pointee_type =
6816 // mem_ptr_type->getPointeeType();
6817 //
6818 // if (TypeSystemClang::IsAggregateType
6819 // (pointee_type.getAsOpaquePtr()))
6820 // {
6821 // return GetIndexOfChildWithName (ast,
6822 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
6823 // name);
6824 // }
6825 // }
6826 // break;
6827 //
6828 case clang::Type::LValueReference:
6829 case clang::Type::RValueReference: {
6830 const clang::ReferenceType *reference_type =
6831 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
6832 clang::QualType pointee_type(reference_type->getPointeeType());
6833 CompilerType pointee_clang_type = GetType(pointee_type);
6834
6835 if (pointee_clang_type.IsAggregateType()) {
6836 return pointee_clang_type.GetIndexOfChildMemberWithName(
6837 name, omit_empty_base_classes, child_indexes);
6838 }
6839 } break;
6840
6841 case clang::Type::Pointer: {
6842 CompilerType pointee_clang_type(GetPointeeType(type));
6843
6844 if (pointee_clang_type.IsAggregateType()) {
6845 return pointee_clang_type.GetIndexOfChildMemberWithName(
6846 name, omit_empty_base_classes, child_indexes);
6847 }
6848 } break;
6849
6850 default:
6851 break;
6852 }
6853 }
6854 return 0;
6855}
6856
6857// Get the index of the child of "clang_type" whose name matches. This function
6858// doesn't descend into the children, but only looks one level deep and name
6859// matches can include base class names.
6860
6861uint32_t
6862TypeSystemClang::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
6863 const char *name,
6864 bool omit_empty_base_classes) {
6865 if (type && name && name[0]) {
6866 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
6867
6868 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6869
6870 switch (type_class) {
6871 case clang::Type::Record:
6872 if (GetCompleteType(type)) {
6873 const clang::RecordType *record_type =
6874 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
6875 const clang::RecordDecl *record_decl = record_type->getDecl();
6876
6877 assert(record_decl)((void)0);
6878 uint32_t child_idx = 0;
6879
6880 const clang::CXXRecordDecl *cxx_record_decl =
6881 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6882
6883 if (cxx_record_decl) {
6884 clang::CXXRecordDecl::base_class_const_iterator base_class,
6885 base_class_end;
6886 for (base_class = cxx_record_decl->bases_begin(),
6887 base_class_end = cxx_record_decl->bases_end();
6888 base_class != base_class_end; ++base_class) {
6889 // Skip empty base classes
6890 clang::CXXRecordDecl *base_class_decl =
6891 llvm::cast<clang::CXXRecordDecl>(
6892 base_class->getType()
6893 ->getAs<clang::RecordType>()
6894 ->getDecl());
6895 if (omit_empty_base_classes &&
6896 !TypeSystemClang::RecordHasFields(base_class_decl))
6897 continue;
6898
6899 CompilerType base_class_clang_type = GetType(base_class->getType());
6900 std::string base_class_type_name(
6901 base_class_clang_type.GetTypeName().AsCString(""));
6902 if (base_class_type_name == name)
6903 return child_idx;
6904 ++child_idx;
6905 }
6906 }
6907
6908 // Try and find a field that matches NAME
6909 clang::RecordDecl::field_iterator field, field_end;
6910 llvm::StringRef name_sref(name);
6911 for (field = record_decl->field_begin(),
6912 field_end = record_decl->field_end();
6913 field != field_end; ++field, ++child_idx) {
6914 if (field->getName().equals(name_sref))
6915 return child_idx;
6916 }
6917 }
6918 break;
6919
6920 case clang::Type::ObjCObject:
6921 case clang::Type::ObjCInterface:
6922 if (GetCompleteType(type)) {
6923 llvm::StringRef name_sref(name);
6924 const clang::ObjCObjectType *objc_class_type =
6925 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
6926 assert(objc_class_type)((void)0);
6927 if (objc_class_type) {
6928 uint32_t child_idx = 0;
6929 clang::ObjCInterfaceDecl *class_interface_decl =
6930 objc_class_type->getInterface();
6931
6932 if (class_interface_decl) {
6933 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
6934 ivar_end = class_interface_decl->ivar_end();
6935 clang::ObjCInterfaceDecl *superclass_interface_decl =
6936 class_interface_decl->getSuperClass();
6937
6938 for (ivar_pos = class_interface_decl->ivar_begin();
6939 ivar_pos != ivar_end; ++ivar_pos, ++child_idx) {
6940 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
6941
6942 if (ivar_decl->getName().equals(name_sref)) {
6943 if ((!omit_empty_base_classes && superclass_interface_decl) ||
6944 (omit_empty_base_classes &&
6945 ObjCDeclHasIVars(superclass_interface_decl, true)))
6946 ++child_idx;
6947
6948 return child_idx;
6949 }
6950 }
6951
6952 if (superclass_interface_decl) {
6953 if (superclass_interface_decl->getName().equals(name_sref))
6954 return 0;
6955 }
6956 }
6957 }
6958 }
6959 break;
6960
6961 case clang::Type::ObjCObjectPointer: {
6962 CompilerType pointee_clang_type = GetType(
6963 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
6964 ->getPointeeType());
6965 return pointee_clang_type.GetIndexOfChildWithName(
6966 name, omit_empty_base_classes);
6967 } break;
6968
6969 case clang::Type::ConstantArray: {
6970 // const clang::ConstantArrayType *array =
6971 // llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
6972 // const uint64_t element_count =
6973 // array->getSize().getLimitedValue();
6974 //
6975 // if (idx < element_count)
6976 // {
6977 // std::pair<uint64_t, unsigned> field_type_info =
6978 // ast->getTypeInfo(array->getElementType());
6979 //
6980 // char element_name[32];
6981 // ::snprintf (element_name, sizeof (element_name),
6982 // "%s[%u]", parent_name ? parent_name : "", idx);
6983 //
6984 // child_name.assign(element_name);
6985 // assert(field_type_info.first % 8 == 0);
6986 // child_byte_size = field_type_info.first / 8;
6987 // child_byte_offset = idx * child_byte_size;
6988 // return array->getElementType().getAsOpaquePtr();
6989 // }
6990 } break;
6991
6992 // case clang::Type::MemberPointerType:
6993 // {
6994 // MemberPointerType *mem_ptr_type =
6995 // llvm::cast<MemberPointerType>(qual_type.getTypePtr());
6996 // clang::QualType pointee_type =
6997 // mem_ptr_type->getPointeeType();
6998 //
6999 // if (TypeSystemClang::IsAggregateType
7000 // (pointee_type.getAsOpaquePtr()))
7001 // {
7002 // return GetIndexOfChildWithName (ast,
7003 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
7004 // name);
7005 // }
7006 // }
7007 // break;
7008 //
7009 case clang::Type::LValueReference:
7010 case clang::Type::RValueReference: {
7011 const clang::ReferenceType *reference_type =
7012 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
7013 CompilerType pointee_type = GetType(reference_type->getPointeeType());
7014
7015 if (pointee_type.IsAggregateType()) {
7016 return pointee_type.GetIndexOfChildWithName(name,
7017 omit_empty_base_classes);
7018 }
7019 } break;
7020
7021 case clang::Type::Pointer: {
7022 const clang::PointerType *pointer_type =
7023 llvm::cast<clang::PointerType>(qual_type.getTypePtr());
7024 CompilerType pointee_type = GetType(pointer_type->getPointeeType());
7025
7026 if (pointee_type.IsAggregateType()) {
7027 return pointee_type.GetIndexOfChildWithName(name,
7028 omit_empty_base_classes);
7029 } else {
7030 // if (parent_name)
7031 // {
7032 // child_name.assign(1, '*');
7033 // child_name += parent_name;
7034 // }
7035 //
7036 // // We have a pointer to an simple type
7037 // if (idx == 0)
7038 // {
7039 // std::pair<uint64_t, unsigned> clang_type_info
7040 // = ast->getTypeInfo(pointee_type);
7041 // assert(clang_type_info.first % 8 == 0);
7042 // child_byte_size = clang_type_info.first / 8;
7043 // child_byte_offset = 0;
7044 // return pointee_type.getAsOpaquePtr();
7045 // }
7046 }
7047 } break;
7048
7049 default:
7050 break;
7051 }
7052 }
7053 return UINT32_MAX0xffffffffU;
7054}
7055
7056size_t
7057TypeSystemClang::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
7058 if (!type)
7059 return 0;
7060
7061 clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
7062 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7063 switch (type_class) {
7064 case clang::Type::Record:
7065 if (GetCompleteType(type)) {
7066 const clang::CXXRecordDecl *cxx_record_decl =
7067 qual_type->getAsCXXRecordDecl();
7068 if (cxx_record_decl) {
7069 const clang::ClassTemplateSpecializationDecl *template_decl =
7070 llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
7071 cxx_record_decl);
7072 if (template_decl)
7073 return template_decl->getTemplateArgs().size();
7074 }
7075 }
7076 break;
7077
7078 default:
7079 break;
7080 }
7081
7082 return 0;
7083}
7084
7085const clang::ClassTemplateSpecializationDecl *
7086TypeSystemClang::GetAsTemplateSpecialization(
7087 lldb::opaque_compiler_type_t type) {
7088 if (!type)
7089 return nullptr;
7090
7091 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
7092 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7093 switch (type_class) {
7094 case clang::Type::Record: {
7095 if (! GetCompleteType(type))
7096 return nullptr;
7097 const clang::CXXRecordDecl *cxx_record_decl =
7098 qual_type->getAsCXXRecordDecl();
7099 if (!cxx_record_decl)
7100 return nullptr;
7101 return llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
7102 cxx_record_decl);
7103 }
7104
7105 default:
7106 return nullptr;
7107 }
7108}
7109
7110lldb::TemplateArgumentKind
7111TypeSystemClang::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
7112 size_t arg_idx) {
7113 const clang::ClassTemplateSpecializationDecl *template_decl =
7114 GetAsTemplateSpecialization(type);
7115 if (! template_decl || arg_idx >= template_decl->getTemplateArgs().size())
7116 return eTemplateArgumentKindNull;
7117
7118 switch (template_decl->getTemplateArgs()[arg_idx].getKind()) {
7119 case clang::TemplateArgument::Null:
7120 return eTemplateArgumentKindNull;
7121
7122 case clang::TemplateArgument::NullPtr:
7123 return eTemplateArgumentKindNullPtr;
7124
7125 case clang::TemplateArgument::Type:
7126 return eTemplateArgumentKindType;
7127
7128 case clang::TemplateArgument::Declaration:
7129 return eTemplateArgumentKindDeclaration;
7130
7131 case clang::TemplateArgument::Integral:
7132 return eTemplateArgumentKindIntegral;
7133
7134 case clang::TemplateArgument::Template:
7135 return eTemplateArgumentKindTemplate;
7136
7137 case clang::TemplateArgument::TemplateExpansion:
7138 return eTemplateArgumentKindTemplateExpansion;
7139
7140 case clang::TemplateArgument::Expression:
7141 return eTemplateArgumentKindExpression;
7142
7143 case clang::TemplateArgument::Pack:
7144 return eTemplateArgumentKindPack;
7145 }
7146 llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind")__builtin_unreachable();
7147}
7148
7149CompilerType
7150TypeSystemClang::GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
7151 size_t idx) {
7152 const clang::ClassTemplateSpecializationDecl *template_decl =
7153 GetAsTemplateSpecialization(type);
7154 if (!template_decl || idx >= template_decl->getTemplateArgs().size())
7155 return CompilerType();
7156
7157 const clang::TemplateArgument &template_arg =
7158 template_decl->getTemplateArgs()[idx];
7159 if (template_arg.getKind() != clang::TemplateArgument::Type)
7160 return CompilerType();
7161
7162 return GetType(template_arg.getAsType());
7163}
7164
7165Optional<CompilerType::IntegralTemplateArgument>
7166TypeSystemClang::GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
7167 size_t idx) {
7168 const clang::ClassTemplateSpecializationDecl *template_decl =
7169 GetAsTemplateSpecialization(type);
7170 if (! template_decl || idx >= template_decl->getTemplateArgs().size())
7171 return llvm::None;
7172
7173 const clang::TemplateArgument &template_arg =
7174 template_decl->getTemplateArgs()[idx];
7175 if (template_arg.getKind() != clang::TemplateArgument::Integral)
7176 return llvm::None;
7177
7178 return {
7179 {template_arg.getAsIntegral(), GetType(template_arg.getIntegralType())}};
7180}
7181
7182CompilerType TypeSystemClang::GetTypeForFormatters(void *type) {
7183 if (type)
7184 return ClangUtil::RemoveFastQualifiers(CompilerType(this, type));
7185 return CompilerType();
7186}
7187
7188clang::EnumDecl *TypeSystemClang::GetAsEnumDecl(const CompilerType &type) {
7189 const clang::EnumType *enutype =
7190 llvm::dyn_cast<clang::EnumType>(ClangUtil::GetCanonicalQualType(type));
7191 if (enutype)
7192 return enutype->getDecl();
7193 return nullptr;
7194}
7195
7196clang::RecordDecl *TypeSystemClang::GetAsRecordDecl(const CompilerType &type) {
7197 const clang::RecordType *record_type =
7198 llvm::dyn_cast<clang::RecordType>(ClangUtil::GetCanonicalQualType(type));
7199 if (record_type)
7200 return record_type->getDecl();
7201 return nullptr;
7202}
7203
7204clang::TagDecl *TypeSystemClang::GetAsTagDecl(const CompilerType &type) {
7205 return ClangUtil::GetAsTagDecl(type);
7206}
7207
7208clang::TypedefNameDecl *
7209TypeSystemClang::GetAsTypedefDecl(const CompilerType &type) {
7210 const clang::TypedefType *typedef_type =
7211 llvm::dyn_cast<clang::TypedefType>(ClangUtil::GetQualType(type));
7212 if (typedef_type)
7213 return typedef_type->getDecl();
7214 return nullptr;
7215}
7216
7217clang::CXXRecordDecl *
7218TypeSystemClang::GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type) {
7219 return GetCanonicalQualType(type)->getAsCXXRecordDecl();
7220}
7221
7222clang::ObjCInterfaceDecl *
7223TypeSystemClang::GetAsObjCInterfaceDecl(const CompilerType &type) {
7224 const clang::ObjCObjectType *objc_class_type =
7225 llvm::dyn_cast<clang::ObjCObjectType>(
7226 ClangUtil::GetCanonicalQualType(type));
7227 if (objc_class_type)
7228 return objc_class_type->getInterface();
7229 return nullptr;
7230}
7231
7232clang::FieldDecl *TypeSystemClang::AddFieldToRecordType(
7233 const CompilerType &type, llvm::StringRef name,
7234 const CompilerType &field_clang_type, AccessType access,
7235 uint32_t bitfield_bit_size) {
7236 if (!type.IsValid() || !field_clang_type.IsValid())
7237 return nullptr;
7238 TypeSystemClang *ast =
7239 llvm::dyn_cast_or_null<TypeSystemClang>(type.GetTypeSystem());
7240 if (!ast)
7241 return nullptr;
7242 clang::ASTContext &clang_ast = ast->getASTContext();
7243 clang::IdentifierInfo *ident = nullptr;
7244 if (!name.empty())
7245 ident = &clang_ast.Idents.get(name);
7246
7247 clang::FieldDecl *field = nullptr;
7248
7249 clang::Expr *bit_width = nullptr;
7250 if (bitfield_bit_size != 0) {
7251 llvm::APInt bitfield_bit_size_apint(clang_ast.getTypeSize(clang_ast.IntTy),
7252 bitfield_bit_size);
7253 bit_width = new (clang_ast)
7254 clang::IntegerLiteral(clang_ast, bitfield_bit_size_apint,
7255 clang_ast.IntTy, clang::SourceLocation());
7256 }
7257
7258 clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7259 if (record_decl) {
7260 field = clang::FieldDecl::CreateDeserialized(clang_ast, 0);
7261 field->setDeclContext(record_decl);
7262 field->setDeclName(ident);
7263 field->setType(ClangUtil::GetQualType(field_clang_type));
7264 if (bit_width)
7265 field->setBitWidth(bit_width);
7266 SetMemberOwningModule(field, record_decl);
7267
7268 if (name.empty()) {
7269 // Determine whether this field corresponds to an anonymous struct or
7270 // union.
7271 if (const clang::TagType *TagT =
7272 field->getType()->getAs<clang::TagType>()) {
7273 if (clang::RecordDecl *Rec =
7274 llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))
7275 if (!Rec->getDeclName()) {
7276 Rec->setAnonymousStructOrUnion(true);
7277 field->setImplicit();
7278 }
7279 }
7280 }
7281
7282 if (field) {
7283 field->setAccess(
7284 TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
7285
7286 record_decl->addDecl(field);
7287
7288 VerifyDecl(field);
7289 }
7290 } else {
7291 clang::ObjCInterfaceDecl *class_interface_decl =
7292 ast->GetAsObjCInterfaceDecl(type);
7293
7294 if (class_interface_decl) {
7295 const bool is_synthesized = false;
7296
7297 field_clang_type.GetCompleteType();
7298
7299 auto *ivar = clang::ObjCIvarDecl::CreateDeserialized(clang_ast, 0);
7300 ivar->setDeclContext(class_interface_decl);
7301 ivar->setDeclName(ident);
7302 ivar->setType(ClangUtil::GetQualType(field_clang_type));
7303 ivar->setAccessControl(ConvertAccessTypeToObjCIvarAccessControl(access));
7304 if (bit_width)
7305 ivar->setBitWidth(bit_width);
7306 ivar->setSynthesize(is_synthesized);
7307 field = ivar;
7308 SetMemberOwningModule(field, class_interface_decl);
7309
7310 if (field) {
7311 class_interface_decl->addDecl(field);
7312
7313 VerifyDecl(field);
7314 }
7315 }
7316 }
7317 return field;
7318}
7319
7320void TypeSystemClang::BuildIndirectFields(const CompilerType &type) {
7321 if (!type)
7322 return;
7323
7324 TypeSystemClang *ast = llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
7325 if (!ast)
7326 return;
7327
7328 clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7329
7330 if (!record_decl)
7331 return;
7332
7333 typedef llvm::SmallVector<clang::IndirectFieldDecl *, 1> IndirectFieldVector;
7334
7335 IndirectFieldVector indirect_fields;
7336 clang::RecordDecl::field_iterator field_pos;
7337 clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end();
7338 clang::RecordDecl::field_iterator last_field_pos = field_end_pos;
7339 for (field_pos = record_decl->field_begin(); field_pos != field_end_pos;
7340 last_field_pos = field_pos++) {
7341 if (field_pos->isAnonymousStructOrUnion()) {
7342 clang::QualType field_qual_type = field_pos->getType();
7343
7344 const clang::RecordType *field_record_type =
7345 field_qual_type->getAs<clang::RecordType>();
7346
7347 if (!field_record_type)
7348 continue;
7349
7350 clang::RecordDecl *field_record_decl = field_record_type->getDecl();
7351
7352 if (!field_record_decl)
7353 continue;
7354
7355 for (clang::RecordDecl::decl_iterator
7356 di = field_record_decl->decls_begin(),
7357 de = field_record_decl->decls_end();
7358 di != de; ++di) {
7359 if (clang::FieldDecl *nested_field_decl =
7360 llvm::dyn_cast<clang::FieldDecl>(*di)) {
7361 clang::NamedDecl **chain =
7362 new (ast->getASTContext()) clang::NamedDecl *[2];
7363 chain[0] = *field_pos;
7364 chain[1] = nested_field_decl;
7365 clang::IndirectFieldDecl *indirect_field =
7366 clang::IndirectFieldDecl::Create(
7367 ast->getASTContext(), record_decl, clang::SourceLocation(),
7368 nested_field_decl->getIdentifier(),
7369 nested_field_decl->getType(), {chain, 2});
7370 SetMemberOwningModule(indirect_field, record_decl);
7371
7372 indirect_field->setImplicit();
7373
7374 indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers(
7375 field_pos->getAccess(), nested_field_decl->getAccess()));
7376
7377 indirect_fields.push_back(indirect_field);
7378 } else if (clang::IndirectFieldDecl *nested_indirect_field_decl =
7379 llvm::dyn_cast<clang::IndirectFieldDecl>(*di)) {
7380 size_t nested_chain_size =
7381 nested_indirect_field_decl->getChainingSize();
7382 clang::NamedDecl **chain = new (ast->getASTContext())
7383 clang::NamedDecl *[nested_chain_size + 1];
7384 chain[0] = *field_pos;
7385
7386 int chain_index = 1;
7387 for (clang::IndirectFieldDecl::chain_iterator
7388 nci = nested_indirect_field_decl->chain_begin(),
7389 nce = nested_indirect_field_decl->chain_end();
7390 nci < nce; ++nci) {
7391 chain[chain_index] = *nci;
7392 chain_index++;
7393 }
7394
7395 clang::IndirectFieldDecl *indirect_field =
7396 clang::IndirectFieldDecl::Create(
7397 ast->getASTContext(), record_decl, clang::SourceLocation(),
7398 nested_indirect_field_decl->getIdentifier(),
7399 nested_indirect_field_decl->getType(),
7400 {chain, nested_chain_size + 1});
7401 SetMemberOwningModule(indirect_field, record_decl);
7402
7403 indirect_field->setImplicit();
7404
7405 indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers(
7406 field_pos->getAccess(), nested_indirect_field_decl->getAccess()));
7407
7408 indirect_fields.push_back(indirect_field);
7409 }
7410 }
7411 }
7412 }
7413
7414 // Check the last field to see if it has an incomplete array type as its last
7415 // member and if it does, the tell the record decl about it
7416 if (last_field_pos != field_end_pos) {
7417 if (last_field_pos->getType()->isIncompleteArrayType())
7418 record_decl->hasFlexibleArrayMember();
7419 }
7420
7421 for (IndirectFieldVector::iterator ifi = indirect_fields.begin(),
7422 ife = indirect_fields.end();
7423 ifi < ife; ++ifi) {
7424 record_decl->addDecl(*ifi);
7425 }
7426}
7427
7428void TypeSystemClang::SetIsPacked(const CompilerType &type) {
7429 if (type) {
7430 TypeSystemClang *ast =
7431 llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
7432 if (ast) {
7433 clang::RecordDecl *record_decl = GetAsRecordDecl(type);
7434
7435 if (!record_decl)
7436 return;
7437
7438 record_decl->addAttr(
7439 clang::PackedAttr::CreateImplicit(ast->getASTContext()));
7440 }
7441 }
7442}
7443
7444clang::VarDecl *TypeSystemClang::AddVariableToRecordType(
7445 const CompilerType &type, llvm::StringRef name,
7446 const CompilerType &var_type, AccessType access) {
7447 if (!type.IsValid() || !var_type.IsValid())
7448 return nullptr;
7449
7450 TypeSystemClang *ast = llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
7451 if (!ast)
7452 return nullptr;
7453
7454 clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7455 if (!record_decl)
7456 return nullptr;
7457
7458 clang::VarDecl *var_decl = nullptr;
7459 clang::IdentifierInfo *ident = nullptr;
7460 if (!name.empty())
7461 ident = &ast->getASTContext().Idents.get(name);
7462
7463 var_decl = clang::VarDecl::CreateDeserialized(ast->getASTContext(), 0);
7464 var_decl->setDeclContext(record_decl);
7465 var_decl->setDeclName(ident);
7466 var_decl->setType(ClangUtil::GetQualType(var_type));
7467 var_decl->setStorageClass(clang::SC_Static);
7468 SetMemberOwningModule(var_decl, record_decl);
7469 if (!var_decl)
7470 return nullptr;
7471
7472 var_decl->setAccess(
7473 TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
7474 record_decl->addDecl(var_decl);
7475
7476 VerifyDecl(var_decl);
7477
7478 return var_decl;
7479}
7480
7481void TypeSystemClang::SetIntegerInitializerForVariable(
7482 VarDecl *var, const llvm::APInt &init_value) {
7483 assert(!var->hasInit() && "variable already initialized")((void)0);
7484
7485 clang::ASTContext &ast = var->getASTContext();
7486 QualType qt = var->getType();
7487 assert(qt->isIntegralOrEnumerationType() &&((void)0)
7488 "only integer or enum types supported")((void)0);
7489 // If the variable is an enum type, take the underlying integer type as
7490 // the type of the integer literal.
7491 if (const EnumType *enum_type = llvm::dyn_cast<EnumType>(qt.getTypePtr())) {
7492 const EnumDecl *enum_decl = enum_type->getDecl();
7493 qt = enum_decl->getIntegerType();
7494 }
7495 var->setInit(IntegerLiteral::Create(ast, init_value, qt.getUnqualifiedType(),
7496 SourceLocation()));
7497}
7498
7499void TypeSystemClang::SetFloatingInitializerForVariable(
7500 clang::VarDecl *var, const llvm::APFloat &init_value) {
7501 assert(!var->hasInit() && "variable already initialized")((void)0);
7502
7503 clang::ASTContext &ast = var->getASTContext();
7504 QualType qt = var->getType();
7505 assert(qt->isFloatingType() && "only floating point types supported")((void)0);
7506 var->setInit(FloatingLiteral::Create(
7507 ast, init_value, true, qt.getUnqualifiedType(), SourceLocation()));
7508}
7509
7510clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType(
7511 lldb::opaque_compiler_type_t type, llvm::StringRef name,
7512 const char *mangled_name, const CompilerType &method_clang_type,
7513 lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
7514 bool is_explicit, bool is_attr_used, bool is_artificial) {
7515 if (!type || !method_clang_type.IsValid() || name.empty())
7516 return nullptr;
7517
7518 clang::QualType record_qual_type(GetCanonicalQualType(type));
7519
7520 clang::CXXRecordDecl *cxx_record_decl =
7521 record_qual_type->getAsCXXRecordDecl();
7522
7523 if (cxx_record_decl == nullptr)
7524 return nullptr;
7525
7526 clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type));
7527
7528 clang::CXXMethodDecl *cxx_method_decl = nullptr;
7529
7530 clang::DeclarationName decl_name(&getASTContext().Idents.get(name));
7531
7532 const clang::FunctionType *function_type =
7533 llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr());
7534
7535 if (function_type == nullptr)
7536 return nullptr;
7537
7538 const clang::FunctionProtoType *method_function_prototype(
7539 llvm::dyn_cast<clang::FunctionProtoType>(function_type));
7540
7541 if (!method_function_prototype)
7542 return nullptr;
7543
7544 unsigned int num_params = method_function_prototype->getNumParams();
7545
7546 clang::CXXDestructorDecl *cxx_dtor_decl(nullptr);
7547 clang::CXXConstructorDecl *cxx_ctor_decl(nullptr);
7548
7549 if (is_artificial)
7550 return nullptr; // skip everything artificial
7551
7552 const clang::ExplicitSpecifier explicit_spec(
7553 nullptr /*expr*/, is_explicit ? clang::ExplicitSpecKind::ResolvedTrue
7554 : clang::ExplicitSpecKind::ResolvedFalse);
7555
7556 if (name.startswith("~")) {
7557 cxx_dtor_decl =
7558 clang::CXXDestructorDecl::CreateDeserialized(getASTContext(), 0);
7559 cxx_dtor_decl->setDeclContext(cxx_record_decl);
7560 cxx_dtor_decl->setDeclName(
7561 getASTContext().DeclarationNames.getCXXDestructorName(
7562 getASTContext().getCanonicalType(record_qual_type)));
7563 cxx_dtor_decl->setType(method_qual_type);
7564 cxx_dtor_decl->setImplicit(is_artificial);
7565 cxx_dtor_decl->setInlineSpecified(is_inline);
7566 cxx_dtor_decl->setConstexprKind(ConstexprSpecKind::Unspecified);
7567 cxx_method_decl = cxx_dtor_decl;
7568 } else if (decl_name == cxx_record_decl->getDeclName()) {
7569 cxx_ctor_decl = clang::CXXConstructorDecl::CreateDeserialized(
7570 getASTContext(), 0, 0);
7571 cxx_ctor_decl->setDeclContext(cxx_record_decl);
7572 cxx_ctor_decl->setDeclName(
7573 getASTContext().DeclarationNames.getCXXConstructorName(
7574 getASTContext().getCanonicalType(record_qual_type)));
7575 cxx_ctor_decl->setType(method_qual_type);
7576 cxx_ctor_decl->setImplicit(is_artificial);
7577 cxx_ctor_decl->setInlineSpecified(is_inline);
7578 cxx_ctor_decl->setConstexprKind(ConstexprSpecKind::Unspecified);
7579 cxx_ctor_decl->setNumCtorInitializers(0);
7580 cxx_ctor_decl->setExplicitSpecifier(explicit_spec);
7581 cxx_method_decl = cxx_ctor_decl;
7582 } else {
7583 clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None;
7584 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
7585
7586 if (IsOperator(name, op_kind)) {
7587 if (op_kind != clang::NUM_OVERLOADED_OPERATORS) {
7588 // Check the number of operator parameters. Sometimes we have seen bad
7589 // DWARF that doesn't correctly describe operators and if we try to
7590 // create a method and add it to the class, clang will assert and
7591 // crash, so we need to make sure things are acceptable.
7592 const bool is_method = true;
7593 if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
7594 is_method, op_kind, num_params))
7595 return nullptr;
7596 cxx_method_decl =
7597 clang::CXXMethodDecl::CreateDeserialized(getASTContext(), 0);
7598 cxx_method_decl->setDeclContext(cxx_record_decl);
7599 cxx_method_decl->setDeclName(
7600 getASTContext().DeclarationNames.getCXXOperatorName(op_kind));
7601 cxx_method_decl->setType(method_qual_type);
7602 cxx_method_decl->setStorageClass(SC);
7603 cxx_method_decl->setInlineSpecified(is_inline);
7604 cxx_method_decl->setConstexprKind(ConstexprSpecKind::Unspecified);
7605 } else if (num_params == 0) {
7606 // Conversion operators don't take params...
7607 auto *cxx_conversion_decl =
7608 clang::CXXConversionDecl::CreateDeserialized(getASTContext(), 0);
7609 cxx_conversion_decl->setDeclContext(cxx_record_decl);
7610 cxx_conversion_decl->setDeclName(
7611 getASTContext().DeclarationNames.getCXXConversionFunctionName(
7612 getASTContext().getCanonicalType(
7613 function_type->getReturnType())));
7614 cxx_conversion_decl->setType(method_qual_type);
7615 cxx_conversion_decl->setInlineSpecified(is_inline);
7616 cxx_conversion_decl->setExplicitSpecifier(explicit_spec);
7617 cxx_conversion_decl->setConstexprKind(ConstexprSpecKind::Unspecified);
7618 cxx_method_decl = cxx_conversion_decl;
7619 }
7620 }
7621
7622 if (cxx_method_decl == nullptr) {
7623 cxx_method_decl =
7624 clang::CXXMethodDecl::CreateDeserialized(getASTContext(), 0);
7625 cxx_method_decl->setDeclContext(cxx_record_decl);
7626 cxx_method_decl->setDeclName(decl_name);
7627 cxx_method_decl->setType(method_qual_type);
7628 cxx_method_decl->setInlineSpecified(is_inline);
7629 cxx_method_decl->setStorageClass(SC);
7630 cxx_method_decl->setConstexprKind(ConstexprSpecKind::Unspecified);
7631 }
7632 }
7633 SetMemberOwningModule(cxx_method_decl, cxx_record_decl);
7634
7635 clang::AccessSpecifier access_specifier =
7636 TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access);
7637
7638 cxx_method_decl->setAccess(access_specifier);
7639 cxx_method_decl->setVirtualAsWritten(is_virtual);
7640
7641 if (is_attr_used)
7642 cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(getASTContext()));
7643
7644 if (mangled_name != nullptr) {
7645 cxx_method_decl->addAttr(clang::AsmLabelAttr::CreateImplicit(
7646 getASTContext(), mangled_name, /*literal=*/false));
7647 }
7648
7649 // Populate the method decl with parameter decls
7650
7651 llvm::SmallVector<clang::ParmVarDecl *, 12> params;
7652
7653 for (unsigned param_index = 0; param_index < num_params; ++param_index) {
7654 params.push_back(clang::ParmVarDecl::Create(
7655 getASTContext(), cxx_method_decl, clang::SourceLocation(),
7656 clang::SourceLocation(),
7657 nullptr, // anonymous
7658 method_function_prototype->getParamType(param_index), nullptr,
7659 clang::SC_None, nullptr));
7660 }
7661
7662 cxx_method_decl->setParams(llvm::ArrayRef<clang::ParmVarDecl *>(params));
7663
7664 cxx_record_decl->addDecl(cxx_method_decl);
7665
7666 // Sometimes the debug info will mention a constructor (default/copy/move),
7667 // destructor, or assignment operator (copy/move) but there won't be any
7668 // version of this in the code. So we check if the function was artificially
7669 // generated and if it is trivial and this lets the compiler/backend know
7670 // that it can inline the IR for these when it needs to and we can avoid a
7671 // "missing function" error when running expressions.
7672
7673 if (is_artificial) {
7674 if (cxx_ctor_decl && ((cxx_ctor_decl->isDefaultConstructor() &&
7675 cxx_record_decl->hasTrivialDefaultConstructor()) ||
7676 (cxx_ctor_decl->isCopyConstructor() &&
7677 cxx_record_decl->hasTrivialCopyConstructor()) ||
7678 (cxx_ctor_decl->isMoveConstructor() &&
7679 cxx_record_decl->hasTrivialMoveConstructor()))) {
7680 cxx_ctor_decl->setDefaulted();
7681 cxx_ctor_decl->setTrivial(true);
7682 } else if (cxx_dtor_decl) {
7683 if (cxx_record_decl->hasTrivialDestructor()) {
7684 cxx_dtor_decl->setDefaulted();
7685 cxx_dtor_decl->setTrivial(true);
7686 }
7687 } else if ((cxx_method_decl->isCopyAssignmentOperator() &&
7688 cxx_record_decl->hasTrivialCopyAssignment()) ||
7689 (cxx_method_decl->isMoveAssignmentOperator() &&
7690 cxx_record_decl->hasTrivialMoveAssignment())) {
7691 cxx_method_decl->setDefaulted();
7692 cxx_method_decl->setTrivial(true);
7693 }
7694 }
7695
7696 VerifyDecl(cxx_method_decl);
7697
7698 return cxx_method_decl;
7699}
7700
7701void TypeSystemClang::AddMethodOverridesForCXXRecordType(
7702 lldb::opaque_compiler_type_t type) {
7703 if (auto *record = GetAsCXXRecordDecl(type))
7704 for (auto *method : record->methods())
7705 addOverridesForMethod(method);
7706}
7707
7708#pragma mark C++ Base Classes
7709
7710std::unique_ptr<clang::CXXBaseSpecifier>
7711TypeSystemClang::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
7712 AccessType access, bool is_virtual,
7713 bool base_of_class) {
7714 if (!type)
7715 return nullptr;
7716
7717 return std::make_unique<clang::CXXBaseSpecifier>(
7718 clang::SourceRange(), is_virtual, base_of_class,
7719 TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access),
7720 getASTContext().getTrivialTypeSourceInfo(GetQualType(type)),
7721 clang::SourceLocation());
7722}
7723
7724bool TypeSystemClang::TransferBaseClasses(
7725 lldb::opaque_compiler_type_t type,
7726 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases) {
7727 if (!type)
7728 return false;
7729 clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type);
7730 if (!cxx_record_decl)
7731 return false;
7732 std::vector<clang::CXXBaseSpecifier *> raw_bases;
7733 raw_bases.reserve(bases.size());
7734
7735 // Clang will make a copy of them, so it's ok that we pass pointers that we're
7736 // about to destroy.
7737 for (auto &b : bases)
7738 raw_bases.push_back(b.get());
7739 cxx_record_decl->setBases(raw_bases.data(), raw_bases.size());
7740 return true;
7741}
7742
7743bool TypeSystemClang::SetObjCSuperClass(
7744 const CompilerType &type, const CompilerType &superclass_clang_type) {
7745 TypeSystemClang *ast =
7746 llvm::dyn_cast_or_null<TypeSystemClang>(type.GetTypeSystem());
7747 if (!ast)
7748 return false;
7749 clang::ASTContext &clang_ast = ast->getASTContext();
7750
7751 if (type && superclass_clang_type.IsValid() &&
7752 superclass_clang_type.GetTypeSystem() == type.GetTypeSystem()) {
7753 clang::ObjCInterfaceDecl *class_interface_decl =
7754 GetAsObjCInterfaceDecl(type);
7755 clang::ObjCInterfaceDecl *super_interface_decl =
7756 GetAsObjCInterfaceDecl(superclass_clang_type);
7757 if (class_interface_decl && super_interface_decl) {
7758 class_interface_decl->setSuperClass(clang_ast.getTrivialTypeSourceInfo(
7759 clang_ast.getObjCInterfaceType(super_interface_decl)));
7760 return true;
7761 }
7762 }
7763 return false;
7764}
7765
7766bool TypeSystemClang::AddObjCClassProperty(
7767 const CompilerType &type, const char *property_name,
7768 const CompilerType &property_clang_type, clang::ObjCIvarDecl *ivar_decl,
7769 const char *property_setter_name, const char *property_getter_name,
7770 uint32_t property_attributes, ClangASTMetadata *metadata) {
7771 if (!type || !property_clang_type.IsValid() || property_name == nullptr ||
7772 property_name[0] == '\0')
7773 return false;
7774 TypeSystemClang *ast = llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
7775 if (!ast)
7776 return false;
7777 clang::ASTContext &clang_ast = ast->getASTContext();
7778
7779 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
7780 if (!class_interface_decl)
7781 return false;
7782
7783 CompilerType property_clang_type_to_access;
7784
7785 if (property_clang_type.IsValid())
7786 property_clang_type_to_access = property_clang_type;
7787 else if (ivar_decl)
7788 property_clang_type_to_access = ast->GetType(ivar_decl->getType());
7789
7790 if (!class_interface_decl || !property_clang_type_to_access.IsValid())
7791 return false;
7792
7793 clang::TypeSourceInfo *prop_type_source;
7794 if (ivar_decl)
7795 prop_type_source = clang_ast.getTrivialTypeSourceInfo(ivar_decl->getType());
7796 else
7797 prop_type_source = clang_ast.getTrivialTypeSourceInfo(
7798 ClangUtil::GetQualType(property_clang_type));
7799
7800 clang::ObjCPropertyDecl *property_decl =
7801 clang::ObjCPropertyDecl::CreateDeserialized(clang_ast, 0);
7802 property_decl->setDeclContext(class_interface_decl);
7803 property_decl->setDeclName(&clang_ast.Idents.get(property_name));
7804 property_decl->setType(ivar_decl
7805 ? ivar_decl->getType()
7806 : ClangUtil::GetQualType(property_clang_type),
7807 prop_type_source);
7808 SetMemberOwningModule(property_decl, class_interface_decl);
7809
7810 if (!property_decl)
7811 return false;
7812
7813 if (metadata)
7814 ast->SetMetadata(property_decl, *metadata);
7815
7816 class_interface_decl->addDecl(property_decl);
7817
7818 clang::Selector setter_sel, getter_sel;
7819
7820 if (property_setter_name) {
7821 std::string property_setter_no_colon(property_setter_name,
7822 strlen(property_setter_name) - 1);
7823 clang::IdentifierInfo *setter_ident =
7824 &clang_ast.Idents.get(property_setter_no_colon);
7825 setter_sel = clang_ast.Selectors.getSelector(1, &setter_ident);
7826 } else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) {
7827 std::string setter_sel_string("set");
7828 setter_sel_string.push_back(::toupper(property_name[0]));
7829 setter_sel_string.append(&property_name[1]);
7830 clang::IdentifierInfo *setter_ident =
7831 &clang_ast.Idents.get(setter_sel_string);
7832 setter_sel = clang_ast.Selectors.getSelector(1, &setter_ident);
7833 }
7834 property_decl->setSetterName(setter_sel);
7835 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_setter);
7836
7837 if (property_getter_name != nullptr) {
7838 clang::IdentifierInfo *getter_ident =
7839 &clang_ast.Idents.get(property_getter_name);
7840 getter_sel = clang_ast.Selectors.getSelector(0, &getter_ident);
7841 } else {
7842 clang::IdentifierInfo *getter_ident = &clang_ast.Idents.get(property_name);
7843 getter_sel = clang_ast.Selectors.getSelector(0, &getter_ident);
7844 }
7845 property_decl->setGetterName(getter_sel);
7846 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_getter);
7847
7848 if (ivar_decl)
7849 property_decl->setPropertyIvarDecl(ivar_decl);
7850
7851 if (property_attributes & DW_APPLE_PROPERTY_readonly)
7852 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_readonly);
7853 if (property_attributes & DW_APPLE_PROPERTY_readwrite)
7854 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_readwrite);
7855 if (property_attributes & DW_APPLE_PROPERTY_assign)
7856 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_assign);
7857 if (property_attributes & DW_APPLE_PROPERTY_retain)
7858 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_retain);
7859 if (property_attributes & DW_APPLE_PROPERTY_copy)
7860 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_copy);
7861 if (property_attributes & DW_APPLE_PROPERTY_nonatomic)
7862 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_nonatomic);
7863 if (property_attributes & ObjCPropertyAttribute::kind_nullability)
7864 property_decl->setPropertyAttributes(
7865 ObjCPropertyAttribute::kind_nullability);
7866 if (property_attributes & ObjCPropertyAttribute::kind_null_resettable)
7867 property_decl->setPropertyAttributes(
7868 ObjCPropertyAttribute::kind_null_resettable);
7869 if (property_attributes & ObjCPropertyAttribute::kind_class)
7870 property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_class);
7871
7872 const bool isInstance =
7873 (property_attributes & ObjCPropertyAttribute::kind_class) == 0;
7874
7875 clang::ObjCMethodDecl *getter = nullptr;
7876 if (!getter_sel.isNull())
7877 getter = isInstance ? class_interface_decl->lookupInstanceMethod(getter_sel)
7878 : class_interface_decl->lookupClassMethod(getter_sel);
7879 if (!getter_sel.isNull() && !getter) {
7880 const bool isVariadic = false;
7881 const bool isPropertyAccessor = true;
7882 const bool isSynthesizedAccessorStub = false;
7883 const bool isImplicitlyDeclared = true;
7884 const bool isDefined = false;
7885 const clang::ObjCMethodDecl::ImplementationControl impControl =
7886 clang::ObjCMethodDecl::None;
7887 const bool HasRelatedResultType = false;
7888
7889 getter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0);
7890 getter->setDeclName(getter_sel);
7891 getter->setReturnType(ClangUtil::GetQualType(property_clang_type_to_access));
7892 getter->setDeclContext(class_interface_decl);
7893 getter->setInstanceMethod(isInstance);
7894 getter->setVariadic(isVariadic);
7895 getter->setPropertyAccessor(isPropertyAccessor);
7896 getter->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
7897 getter->setImplicit(isImplicitlyDeclared);
7898 getter->setDefined(isDefined);
7899 getter->setDeclImplementation(impControl);
7900 getter->setRelatedResultType(HasRelatedResultType);
7901 SetMemberOwningModule(getter, class_interface_decl);
7902
7903 if (getter) {
7904 if (metadata)
7905 ast->SetMetadata(getter, *metadata);
7906
7907 getter->setMethodParams(clang_ast, llvm::ArrayRef<clang::ParmVarDecl *>(),
7908 llvm::ArrayRef<clang::SourceLocation>());
7909 class_interface_decl->addDecl(getter);
7910 }
7911 }
7912 if (getter) {
7913 getter->setPropertyAccessor(true);
7914 property_decl->setGetterMethodDecl(getter);
7915 }
7916
7917 clang::ObjCMethodDecl *setter = nullptr;
7918 setter = isInstance ? class_interface_decl->lookupInstanceMethod(setter_sel)
7919 : class_interface_decl->lookupClassMethod(setter_sel);
7920 if (!setter_sel.isNull() && !setter) {
7921 clang::QualType result_type = clang_ast.VoidTy;
7922 const bool isVariadic = false;
7923 const bool isPropertyAccessor = true;
7924 const bool isSynthesizedAccessorStub = false;
7925 const bool isImplicitlyDeclared = true;
7926 const bool isDefined = false;
7927 const clang::ObjCMethodDecl::ImplementationControl impControl =
7928 clang::ObjCMethodDecl::None;
7929 const bool HasRelatedResultType = false;
7930
7931 setter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0);
7932 setter->setDeclName(setter_sel);
7933 setter->setReturnType(result_type);
7934 setter->setDeclContext(class_interface_decl);
7935 setter->setInstanceMethod(isInstance);
7936 setter->setVariadic(isVariadic);
7937 setter->setPropertyAccessor(isPropertyAccessor);
7938 setter->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
7939 setter->setImplicit(isImplicitlyDeclared);
7940 setter->setDefined(isDefined);
7941 setter->setDeclImplementation(impControl);
7942 setter->setRelatedResultType(HasRelatedResultType);
7943 SetMemberOwningModule(setter, class_interface_decl);
7944
7945 if (setter) {
7946 if (metadata)
7947 ast->SetMetadata(setter, *metadata);
7948
7949 llvm::SmallVector<clang::ParmVarDecl *, 1> params;
7950 params.push_back(clang::ParmVarDecl::Create(
7951 clang_ast, setter, clang::SourceLocation(), clang::SourceLocation(),
7952 nullptr, // anonymous
7953 ClangUtil::GetQualType(property_clang_type_to_access), nullptr,
7954 clang::SC_Auto, nullptr));
7955
7956 setter->setMethodParams(clang_ast,
7957 llvm::ArrayRef<clang::ParmVarDecl *>(params),
7958 llvm::ArrayRef<clang::SourceLocation>());
7959
7960 class_interface_decl->addDecl(setter);
7961 }
7962 }
7963 if (setter) {
7964 setter->setPropertyAccessor(true);
7965 property_decl->setSetterMethodDecl(setter);
7966 }
7967
7968 return true;
7969}
7970
7971bool TypeSystemClang::IsObjCClassTypeAndHasIVars(const CompilerType &type,
7972 bool check_superclass) {
7973 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
7974 if (class_interface_decl)
7975 return ObjCDeclHasIVars(class_interface_decl, check_superclass);
7976 return false;
7977}
7978
7979clang::ObjCMethodDecl *TypeSystemClang::AddMethodToObjCObjectType(
7980 const CompilerType &type,
7981 const char *name, // the full symbol name as seen in the symbol table
7982 // (lldb::opaque_compiler_type_t type, "-[NString
7983 // stringWithCString:]")
7984 const CompilerType &method_clang_type, lldb::AccessType access,
7985 bool is_artificial, bool is_variadic, bool is_objc_direct_call) {
7986 if (!type || !method_clang_type.IsValid())
7987 return nullptr;
7988
7989 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
7990
7991 if (class_interface_decl == nullptr)
7992 return nullptr;
7993 TypeSystemClang *lldb_ast =
7994 llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
7995 if (lldb_ast == nullptr)
7996 return nullptr;
7997 clang::ASTContext &ast = lldb_ast->getASTContext();
7998
7999 const char *selector_start = ::strchr(name, ' ');
8000 if (selector_start == nullptr)
8001 return nullptr;
8002
8003 selector_start++;
8004 llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents;
8005
8006 size_t len = 0;
8007 const char *start;
8008
8009 unsigned num_selectors_with_args = 0;
8010 for (start = selector_start; start && *start != '\0' && *start != ']';
8011 start += len) {
8012 len = ::strcspn(start, ":]");
8013 bool has_arg = (start[len] == ':');
8014 if (has_arg)
8015 ++num_selectors_with_args;
8016 selector_idents.push_back(&ast.Idents.get(llvm::StringRef(start, len)));
8017 if (has_arg)
8018 len += 1;
8019 }
8020
8021 if (selector_idents.size() == 0)
8022 return nullptr;
8023
8024 clang::Selector method_selector = ast.Selectors.getSelector(
8025 num_selectors_with_args ? selector_idents.size() : 0,
8026 selector_idents.data());
8027
8028 clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type));
8029
8030 // Populate the method decl with parameter decls
8031 const clang::Type *method_type(method_qual_type.getTypePtr());
8032
8033 if (method_type == nullptr)
8034 return nullptr;
8035
8036 const clang::FunctionProtoType *method_function_prototype(
8037 llvm::dyn_cast<clang::FunctionProtoType>(method_type));
8038
8039 if (!method_function_prototype)
8040 return nullptr;
8041
8042 const bool isInstance = (name[0] == '-');
8043 const bool isVariadic = is_variadic;
8044 const bool isPropertyAccessor = false;
8045 const bool isSynthesizedAccessorStub = false;
8046 /// Force this to true because we don't have source locations.
8047 const bool isImplicitlyDeclared = true;
8048 const bool isDefined = false;
8049 const clang::ObjCMethodDecl::ImplementationControl impControl =
8050 clang::ObjCMethodDecl::None;
8051 const bool HasRelatedResultType = false;
8052
8053 const unsigned num_args = method_function_prototype->getNumParams();
8054
8055 if (num_args != num_selectors_with_args)
8056 return nullptr; // some debug information is corrupt. We are not going to
8057 // deal with it.
8058
8059 auto *objc_method_decl = clang::ObjCMethodDecl::CreateDeserialized(ast, 0);
8060 objc_method_decl->setDeclName(method_selector);
8061 objc_method_decl->setReturnType(method_function_prototype->getReturnType());
8062 objc_method_decl->setDeclContext(
8063 lldb_ast->GetDeclContextForType(ClangUtil::GetQualType(type)));
8064 objc_method_decl->setInstanceMethod(isInstance);
8065 objc_method_decl->setVariadic(isVariadic);
8066 objc_method_decl->setPropertyAccessor(isPropertyAccessor);
8067 objc_method_decl->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
8068 objc_method_decl->setImplicit(isImplicitlyDeclared);
8069 objc_method_decl->setDefined(isDefined);
8070 objc_method_decl->setDeclImplementation(impControl);
8071 objc_method_decl->setRelatedResultType(HasRelatedResultType);
8072 SetMemberOwningModule(objc_method_decl, class_interface_decl);
8073
8074 if (objc_method_decl == nullptr)
8075 return nullptr;
8076
8077 if (num_args > 0) {
8078 llvm::SmallVector<clang::ParmVarDecl *, 12> params;
8079
8080 for (unsigned param_index = 0; param_index < num_args; ++param_index) {
8081 params.push_back(clang::ParmVarDecl::Create(
8082 ast, objc_method_decl, clang::SourceLocation(),
8083 clang::SourceLocation(),
8084 nullptr, // anonymous
8085 method_function_prototype->getParamType(param_index), nullptr,
8086 clang::SC_Auto, nullptr));
8087 }
8088
8089 objc_method_decl->setMethodParams(
8090 ast, llvm::ArrayRef<clang::ParmVarDecl *>(params),
8091 llvm::ArrayRef<clang::SourceLocation>());
8092 }
8093
8094 if (is_objc_direct_call) {
8095 // Add a the objc_direct attribute to the declaration we generate that
8096 // we generate a direct method call for this ObjCMethodDecl.
8097 objc_method_decl->addAttr(
8098 clang::ObjCDirectAttr::CreateImplicit(ast, SourceLocation()));
8099 // Usually Sema is creating implicit parameters (e.g., self) when it
8100 // parses the method. We don't have a parsing Sema when we build our own
8101 // AST here so we manually need to create these implicit parameters to
8102 // make the direct call code generation happy.
8103 objc_method_decl->createImplicitParams(ast, class_interface_decl);
8104 }
8105
8106 class_interface_decl->addDecl(objc_method_decl);
8107
8108 VerifyDecl(objc_method_decl);
8109
8110 return objc_method_decl;
8111}
8112
8113bool TypeSystemClang::SetHasExternalStorage(lldb::opaque_compiler_type_t type,
8114 bool has_extern) {
8115 if (!type)
8116 return false;
8117
8118 clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
8119
8120 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8121 switch (type_class) {
8122 case clang::Type::Record: {
8123 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
8124 if (cxx_record_decl) {
8125 cxx_record_decl->setHasExternalLexicalStorage(has_extern);
8126 cxx_record_decl->setHasExternalVisibleStorage(has_extern);
8127 return true;
8128 }
8129 } break;
8130
8131 case clang::Type::Enum: {
8132 clang::EnumDecl *enum_decl =
8133 llvm::cast<clang::EnumType>(qual_type)->getDecl();
8134 if (enum_decl) {
8135 enum_decl->setHasExternalLexicalStorage(has_extern);
8136 enum_decl->setHasExternalVisibleStorage(has_extern);
8137 return true;
8138 }
8139 } break;
8140
8141 case clang::Type::ObjCObject:
8142 case clang::Type::ObjCInterface: {
8143 const clang::ObjCObjectType *objc_class_type =
8144 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
8145 assert(objc_class_type)((void)0);
8146 if (objc_class_type) {
8147 clang::ObjCInterfaceDecl *class_interface_decl =
8148 objc_class_type->getInterface();
8149
8150 if (class_interface_decl) {
8151 class_interface_decl->setHasExternalLexicalStorage(has_extern);
8152 class_interface_decl->setHasExternalVisibleStorage(has_extern);
8153 return true;
8154 }
8155 }
8156 } break;
8157
8158 default:
8159 break;
8160 }
8161 return false;
8162}
8163
8164#pragma mark TagDecl
8165
8166bool TypeSystemClang::StartTagDeclarationDefinition(const CompilerType &type) {
8167 clang::QualType qual_type(ClangUtil::GetQualType(type));
8168 if (!qual_type.isNull()) {
8169 const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
8170 if (tag_type) {
8171 clang::TagDecl *tag_decl = tag_type->getDecl();
8172 if (tag_decl) {
8173 tag_decl->startDefinition();
8174 return true;
8175 }
8176 }
8177
8178 const clang::ObjCObjectType *object_type =
8179 qual_type->getAs<clang::ObjCObjectType>();
8180 if (object_type) {
8181 clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface();
8182 if (interface_decl) {
8183 interface_decl->startDefinition();
8184 return true;
8185 }
8186 }
8187 }
8188 return false;
8189}
8190
8191bool TypeSystemClang::CompleteTagDeclarationDefinition(
8192 const CompilerType &type) {
8193 clang::QualType qual_type(ClangUtil::GetQualType(type));
8194 if (qual_type.isNull())
8195 return false;
8196
8197 // Make sure we use the same methodology as
8198 // TypeSystemClang::StartTagDeclarationDefinition() as to how we start/end
8199 // the definition.
8200 const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
8201 if (tag_type) {
8202 clang::TagDecl *tag_decl = tag_type->getDecl();
8203
8204 if (auto *cxx_record_decl = llvm::dyn_cast<CXXRecordDecl>(tag_decl)) {
8205 // If we have a move constructor declared but no copy constructor we
8206 // need to explicitly mark it as deleted. Usually Sema would do this for
8207 // us in Sema::DeclareImplicitCopyConstructor but we don't have a Sema
8208 // when building an AST from debug information.
8209 // See also:
8210 // C++11 [class.copy]p7, p18:
8211 // If the class definition declares a move constructor or move assignment
8212 // operator, an implicitly declared copy constructor or copy assignment
8213 // operator is defined as deleted.
8214 if (cxx_record_decl->hasUserDeclaredMoveConstructor() ||
8215 cxx_record_decl->hasUserDeclaredMoveAssignment()) {
8216 if (cxx_record_decl->needsImplicitCopyConstructor())
8217 cxx_record_decl->setImplicitCopyConstructorIsDeleted();
8218 if (cxx_record_decl->needsImplicitCopyAssignment())
8219 cxx_record_decl->setImplicitCopyAssignmentIsDeleted();
8220 }
8221
8222 if (!cxx_record_decl->isCompleteDefinition())
8223 cxx_record_decl->completeDefinition();
8224 cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
8225 cxx_record_decl->setHasExternalLexicalStorage(false);
8226 cxx_record_decl->setHasExternalVisibleStorage(false);
8227 return true;
8228 }
8229 }
8230
8231 const clang::EnumType *enutype = qual_type->getAs<clang::EnumType>();
8232
8233 if (!enutype)
8234 return false;
8235 clang::EnumDecl *enum_decl = enutype->getDecl();
8236
8237 if (enum_decl->isCompleteDefinition())
8238 return true;
8239
8240 TypeSystemClang *lldb_ast =
8241 llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
8242 if (lldb_ast == nullptr)
8243 return false;
8244 clang::ASTContext &ast = lldb_ast->getASTContext();
8245
8246 /// TODO This really needs to be fixed.
8247
8248 QualType integer_type(enum_decl->getIntegerType());
8249 if (!integer_type.isNull()) {
8250 unsigned NumPositiveBits = 1;
8251 unsigned NumNegativeBits = 0;
8252
8253 clang::QualType promotion_qual_type;
8254 // If the enum integer type is less than an integer in bit width,
8255 // then we must promote it to an integer size.
8256 if (ast.getTypeSize(enum_decl->getIntegerType()) <
8257 ast.getTypeSize(ast.IntTy)) {
8258 if (enum_decl->getIntegerType()->isSignedIntegerType())
8259 promotion_qual_type = ast.IntTy;
8260 else
8261 promotion_qual_type = ast.UnsignedIntTy;
8262 } else
8263 promotion_qual_type = enum_decl->getIntegerType();
8264
8265 enum_decl->completeDefinition(enum_decl->getIntegerType(),
8266 promotion_qual_type, NumPositiveBits,
8267 NumNegativeBits);
8268 }
8269 return true;
8270}
8271
8272clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
8273 const CompilerType &enum_type, const Declaration &decl, const char *name,
8274 const llvm::APSInt &value) {
8275
8276 if (!enum_type || ConstString(name).IsEmpty())
8277 return nullptr;
8278
8279 lldbassert(enum_type.GetTypeSystem() == static_cast<TypeSystem *>(this))lldb_private::lldb_assert(static_cast<bool>(enum_type.GetTypeSystem
() == static_cast<TypeSystem *>(this)), "enum_type.GetTypeSystem() == static_cast<TypeSystem *>(this)"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, 8279)
;
8280
8281 lldb::opaque_compiler_type_t enum_opaque_compiler_type =
8282 enum_type.GetOpaqueQualType();
8283
8284 if (!enum_opaque_compiler_type)
8285 return nullptr;
8286
8287 clang::QualType enum_qual_type(
8288 GetCanonicalQualType(enum_opaque_compiler_type));
8289
8290 const clang::Type *clang_type = enum_qual_type.getTypePtr();
8291
8292 if (!clang_type)
8293 return nullptr;
8294
8295 const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
8296
8297 if (!enutype)
8298 return nullptr;
8299
8300 clang::EnumConstantDecl *enumerator_decl =
8301 clang::EnumConstantDecl::CreateDeserialized(getASTContext(), 0);
8302 enumerator_decl->setDeclContext(enutype->getDecl());
8303 if (name && name[0])
8304 enumerator_decl->setDeclName(&getASTContext().Idents.get(name));
8305 enumerator_decl->setType(clang::QualType(enutype, 0));
8306 enumerator_decl->setInitVal(value);
8307 SetMemberOwningModule(enumerator_decl, enutype->getDecl());
8308
8309 if (!enumerator_decl)
8310 return nullptr;
8311
8312 enutype->getDecl()->addDecl(enumerator_decl);
8313
8314 VerifyDecl(enumerator_decl);
8315 return enumerator_decl;
8316}
8317
8318clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
8319 const CompilerType &enum_type, const Declaration &decl, const char *name,
8320 int64_t enum_value, uint32_t enum_value_bit_size) {
8321 CompilerType underlying_type = GetEnumerationIntegerType(enum_type);
8322 bool is_signed = false;
8323 underlying_type.IsIntegerType(is_signed);
8324
8325 llvm::APSInt value(enum_value_bit_size, is_signed);
8326 value = enum_value;
8327
8328 return AddEnumerationValueToEnumerationType(enum_type, decl, name, value);
8329}
8330
8331CompilerType TypeSystemClang::GetEnumerationIntegerType(CompilerType type) {
8332 clang::QualType qt(ClangUtil::GetQualType(type));
8333 const clang::Type *clang_type = qt.getTypePtrOrNull();
8334 const auto *enum_type = llvm::dyn_cast_or_null<clang::EnumType>(clang_type);
8335 if (!enum_type)
8336 return CompilerType();
8337
8338 return GetType(enum_type->getDecl()->getIntegerType());
8339}
8340
8341CompilerType
8342TypeSystemClang::CreateMemberPointerType(const CompilerType &type,
8343 const CompilerType &pointee_type) {
8344 if (type && pointee_type.IsValid() &&
8345 type.GetTypeSystem() == pointee_type.GetTypeSystem()) {
8346 TypeSystemClang *ast =
8347 llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
8348 if (!ast)
8349 return CompilerType();
8350 return ast->GetType(ast->getASTContext().getMemberPointerType(
8351 ClangUtil::GetQualType(pointee_type),
8352 ClangUtil::GetQualType(type).getTypePtr()));
8353 }
8354 return CompilerType();
8355}
8356
8357// Dumping types
8358#define DEPTH_INCREMENT2 2
8359
8360#ifndef NDEBUG1
8361LLVM_DUMP_METHOD__attribute__((noinline)) void
8362TypeSystemClang::dump(lldb::opaque_compiler_type_t type) const {
8363 if (!type)
8364 return;
8365 clang::QualType qual_type(GetQualType(type));
8366 qual_type.dump();
8367}
8368#endif
8369
8370void TypeSystemClang::Dump(Stream &s) {
8371 Decl *tu = Decl::castFromDeclContext(GetTranslationUnitDecl());
8372 tu->dump(s.AsRawOstream());
8373}
8374
8375void TypeSystemClang::DumpFromSymbolFile(Stream &s,
8376 llvm::StringRef symbol_name) {
8377 SymbolFile *symfile = GetSymbolFile();
8378
8379 if (!symfile)
8380 return;
8381
8382 lldb_private::TypeList type_list;
8383 symfile->GetTypes(nullptr, eTypeClassAny, type_list);
8384 size_t ntypes = type_list.GetSize();
8385
8386 for (size_t i = 0; i < ntypes; ++i) {
8387 TypeSP type = type_list.GetTypeAtIndex(i);
8388
8389 if (!symbol_name.empty())
8390 if (symbol_name != type->GetName().GetStringRef())
8391 continue;
8392
8393 s << type->GetName().AsCString() << "\n";
8394
8395 CompilerType full_type = type->GetFullCompilerType();
8396 if (clang::TagDecl *tag_decl = GetAsTagDecl(full_type)) {
8397 tag_decl->dump(s.AsRawOstream());
8398 continue;
8399 }
8400 if (clang::TypedefNameDecl *typedef_decl = GetAsTypedefDecl(full_type)) {
8401 typedef_decl->dump(s.AsRawOstream());
8402 continue;
8403 }
8404 if (auto *objc_obj = llvm::dyn_cast<clang::ObjCObjectType>(
8405 ClangUtil::GetQualType(full_type).getTypePtr())) {
8406 if (clang::ObjCInterfaceDecl *interface_decl = objc_obj->getInterface()) {
8407 interface_decl->dump(s.AsRawOstream());
8408 continue;
8409 }
8410 }
8411 GetCanonicalQualType(full_type.GetOpaqueQualType())
8412 .dump(s.AsRawOstream(), getASTContext());
8413 }
8414}
8415
8416void TypeSystemClang::DumpValue(
8417 lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
8418 lldb::Format format, const lldb_private::DataExtractor &data,
8419 lldb::offset_t data_byte_offset, size_t data_byte_size,
8420 uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
8421 bool show_summary, bool verbose, uint32_t depth) {
8422 if (!type)
1
Assuming 'type' is non-null
2
Taking false branch
8423 return;
8424
8425 clang::QualType qual_type(GetQualType(type));
8426 switch (qual_type->getTypeClass()) {
3
Control jumps to 'case Record:' at line 8427
8427 case clang::Type::Record:
8428 if (GetCompleteType(type)) {
4
Assuming the condition is true
5
Taking true branch
8429 const clang::RecordType *record_type =
8430 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
6
The object is a 'RecordType'
8431 const clang::RecordDecl *record_decl = record_type->getDecl();
8432 assert(record_decl)((void)0);
8433 uint32_t field_bit_offset = 0;
8434 uint32_t field_byte_offset = 0;
8435 const clang::ASTRecordLayout &record_layout =
8436 getASTContext().getASTRecordLayout(record_decl);
8437 uint32_t child_idx = 0;
8438
8439 const clang::CXXRecordDecl *cxx_record_decl =
8440 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
7
Assuming 'record_decl' is a 'CXXRecordDecl'
8441 if (cxx_record_decl
7.1
'cxx_record_decl' is non-null
7.1
'cxx_record_decl' is non-null
7.1
'cxx_record_decl' is non-null
) {
8
Taking true branch
8442 // We might have base classes to print out first
8443 clang::CXXRecordDecl::base_class_const_iterator base_class,
8444 base_class_end;
8445 for (base_class = cxx_record_decl->bases_begin(),
9
Loop condition is true. Entering loop body
8446 base_class_end = cxx_record_decl->bases_end();
8447 base_class != base_class_end; ++base_class) {
8448 const clang::CXXRecordDecl *base_class_decl =
8449 llvm::cast<clang::CXXRecordDecl>(
11
The object is a 'CXXRecordDecl'
8450 base_class->getType()->getAs<clang::RecordType>()->getDecl());
10
Assuming the object is a 'RecordType'
8451
8452 // Skip empty base classes
8453 if (!verbose && !TypeSystemClang::RecordHasFields(base_class_decl))
12
Assuming 'verbose' is false
13
Calling 'TypeSystemClang::RecordHasFields'
8454 continue;
8455
8456 if (base_class->isVirtual())
8457 field_bit_offset =
8458 record_layout.getVBaseClassOffset(base_class_decl)
8459 .getQuantity() *
8460 8;
8461 else
8462 field_bit_offset = record_layout.getBaseClassOffset(base_class_decl)
8463 .getQuantity() *
8464 8;
8465 field_byte_offset = field_bit_offset / 8;
8466 assert(field_bit_offset % 8 == 0)((void)0);
8467 if (child_idx == 0)
8468 s->PutChar('{');
8469 else
8470 s->PutChar(',');
8471
8472 clang::QualType base_class_qual_type = base_class->getType();
8473 std::string base_class_type_name(base_class_qual_type.getAsString());
8474
8475 // Indent and print the base class type name
8476 s->Format("\n{0}{1}", llvm::fmt_repeat(" ", depth + DEPTH_INCREMENT2),
8477 base_class_type_name);
8478
8479 clang::TypeInfo base_class_type_info =
8480 getASTContext().getTypeInfo(base_class_qual_type);
8481
8482 // Dump the value of the member
8483 CompilerType base_clang_type = GetType(base_class_qual_type);
8484 base_clang_type.DumpValue(
8485 exe_ctx,
8486 s, // Stream to dump to
8487 base_clang_type
8488 .GetFormat(), // The format with which to display the member
8489 data, // Data buffer containing all bytes for this type
8490 data_byte_offset + field_byte_offset, // Offset into "data" where
8491 // to grab value from
8492 base_class_type_info.Width / 8, // Size of this type in bytes
8493 0, // Bitfield bit size
8494 0, // Bitfield bit offset
8495 show_types, // Boolean indicating if we should show the variable
8496 // types
8497 show_summary, // Boolean indicating if we should show a summary
8498 // for the current type
8499 verbose, // Verbose output?
8500 depth + DEPTH_INCREMENT2); // Scope depth for any types that have
8501 // children
8502
8503 ++child_idx;
8504 }
8505 }
8506 uint32_t field_idx = 0;
8507 clang::RecordDecl::field_iterator field, field_end;
8508 for (field = record_decl->field_begin(),
8509 field_end = record_decl->field_end();
8510 field != field_end; ++field, ++field_idx, ++child_idx) {
8511 // Print the starting squiggly bracket (if this is the first member) or
8512 // comma (for member 2 and beyond) for the struct/union/class member.
8513 if (child_idx == 0)
8514 s->PutChar('{');
8515 else
8516 s->PutChar(',');
8517
8518 // Indent
8519 s->Printf("\n%*s", depth + DEPTH_INCREMENT2, "");
8520
8521 clang::QualType field_type = field->getType();
8522 // Print the member type if requested
8523 // Figure out the type byte size (field_type_info.first) and alignment
8524 // (field_type_info.second) from the AST context.
8525 clang::TypeInfo field_type_info =
8526 getASTContext().getTypeInfo(field_type);
8527 assert(field_idx < record_layout.getFieldCount())((void)0);
8528 // Figure out the field offset within the current struct/union/class
8529 // type
8530 field_bit_offset = record_layout.getFieldOffset(field_idx);
8531 field_byte_offset = field_bit_offset / 8;
8532 uint32_t field_bitfield_bit_size = 0;
8533 uint32_t field_bitfield_bit_offset = 0;
8534 if (FieldIsBitfield(*field, field_bitfield_bit_size))
8535 field_bitfield_bit_offset = field_bit_offset % 8;
8536
8537 if (show_types) {
8538 std::string field_type_name(field_type.getAsString());
8539 if (field_bitfield_bit_size > 0)
8540 s->Printf("(%s:%u) ", field_type_name.c_str(),
8541 field_bitfield_bit_size);
8542 else
8543 s->Printf("(%s) ", field_type_name.c_str());
8544 }
8545 // Print the member name and equal sign
8546 s->Printf("%s = ", field->getNameAsString().c_str());
8547
8548 // Dump the value of the member
8549 CompilerType field_clang_type = GetType(field_type);
8550 field_clang_type.DumpValue(
8551 exe_ctx,
8552 s, // Stream to dump to
8553 field_clang_type
8554 .GetFormat(), // The format with which to display the member
8555 data, // Data buffer containing all bytes for this type
8556 data_byte_offset + field_byte_offset, // Offset into "data" where to
8557 // grab value from
8558 field_type_info.Width / 8, // Size of this type in bytes
8559 field_bitfield_bit_size, // Bitfield bit size
8560 field_bitfield_bit_offset, // Bitfield bit offset
8561 show_types, // Boolean indicating if we should show the variable
8562 // types
8563 show_summary, // Boolean indicating if we should show a summary for
8564 // the current type
8565 verbose, // Verbose output?
8566 depth + DEPTH_INCREMENT2); // Scope depth for any types that have
8567 // children
8568 }
8569
8570 // Indent the trailing squiggly bracket
8571 if (child_idx > 0)
8572 s->Printf("\n%*s}", depth, "");
8573 }
8574 return;
8575
8576 case clang::Type::Enum:
8577 if (GetCompleteType(type)) {
8578 const clang::EnumType *enutype =
8579 llvm::cast<clang::EnumType>(qual_type.getTypePtr());
8580 const clang::EnumDecl *enum_decl = enutype->getDecl();
8581 assert(enum_decl)((void)0);
8582 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
8583 lldb::offset_t offset = data_byte_offset;
8584 const int64_t enum_value = data.GetMaxU64Bitfield(
8585 &offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset);
8586 for (enum_pos = enum_decl->enumerator_begin(),
8587 enum_end_pos = enum_decl->enumerator_end();
8588 enum_pos != enum_end_pos; ++enum_pos) {
8589 if (enum_pos->getInitVal() == enum_value) {
8590 s->Printf("%s", enum_pos->getNameAsString().c_str());
8591 return;
8592 }
8593 }
8594 // If we have gotten here we didn't get find the enumerator in the enum
8595 // decl, so just print the integer.
8596 s->Printf("%" PRIi64"lli", enum_value);
8597 }
8598 return;
8599
8600 case clang::Type::ConstantArray: {
8601 const clang::ConstantArrayType *array =
8602 llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr());
8603 bool is_array_of_characters = false;
8604 clang::QualType element_qual_type = array->getElementType();
8605
8606 const clang::Type *canonical_type =
8607 element_qual_type->getCanonicalTypeInternal().getTypePtr();
8608 if (canonical_type)
8609 is_array_of_characters = canonical_type->isCharType();
8610
8611 const uint64_t element_count = array->getSize().getLimitedValue();
8612
8613 clang::TypeInfo field_type_info =
8614 getASTContext().getTypeInfo(element_qual_type);
8615
8616 uint32_t element_idx = 0;
8617 uint32_t element_offset = 0;
8618 uint64_t element_byte_size = field_type_info.Width / 8;
8619 uint32_t element_stride = element_byte_size;
8620
8621 if (is_array_of_characters) {
8622 s->PutChar('"');
8623 DumpDataExtractor(data, s, data_byte_offset, lldb::eFormatChar,
8624 element_byte_size, element_count, UINT32_MAX0xffffffffU,
8625 LLDB_INVALID_ADDRESS0xffffffffffffffffULL, 0, 0);
8626 s->PutChar('"');
8627 return;
8628 } else {
8629 CompilerType element_clang_type = GetType(element_qual_type);
8630 lldb::Format element_format = element_clang_type.GetFormat();
8631
8632 for (element_idx = 0; element_idx < element_count; ++element_idx) {
8633 // Print the starting squiggly bracket (if this is the first member) or
8634 // comman (for member 2 and beyong) for the struct/union/class member.
8635 if (element_idx == 0)
8636 s->PutChar('{');
8637 else
8638 s->PutChar(',');
8639
8640 // Indent and print the index
8641 s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT2, "", element_idx);
8642
8643 // Figure out the field offset within the current struct/union/class
8644 // type
8645 element_offset = element_idx * element_stride;
8646
8647 // Dump the value of the member
8648 element_clang_type.DumpValue(
8649 exe_ctx,
8650 s, // Stream to dump to
8651 element_format, // The format with which to display the element
8652 data, // Data buffer containing all bytes for this type
8653 data_byte_offset +
8654 element_offset, // Offset into "data" where to grab value from
8655 element_byte_size, // Size of this type in bytes
8656 0, // Bitfield bit size
8657 0, // Bitfield bit offset
8658 show_types, // Boolean indicating if we should show the variable
8659 // types
8660 show_summary, // Boolean indicating if we should show a summary for
8661 // the current type
8662 verbose, // Verbose output?
8663 depth + DEPTH_INCREMENT2); // Scope depth for any types that have
8664 // children
8665 }
8666
8667 // Indent the trailing squiggly bracket
8668 if (element_idx > 0)
8669 s->Printf("\n%*s}", depth, "");
8670 }
8671 }
8672 return;
8673
8674 case clang::Type::Typedef: {
8675 clang::QualType typedef_qual_type =
8676 llvm::cast<clang::TypedefType>(qual_type)
8677 ->getDecl()
8678 ->getUnderlyingType();
8679
8680 CompilerType typedef_clang_type = GetType(typedef_qual_type);
8681 lldb::Format typedef_format = typedef_clang_type.GetFormat();
8682 clang::TypeInfo typedef_type_info =
8683 getASTContext().getTypeInfo(typedef_qual_type);
8684 uint64_t typedef_byte_size = typedef_type_info.Width / 8;
8685
8686 return typedef_clang_type.DumpValue(
8687 exe_ctx,
8688 s, // Stream to dump to
8689 typedef_format, // The format with which to display the element
8690 data, // Data buffer containing all bytes for this type
8691 data_byte_offset, // Offset into "data" where to grab value from
8692 typedef_byte_size, // Size of this type in bytes
8693 bitfield_bit_size, // Bitfield bit size
8694 bitfield_bit_offset, // Bitfield bit offset
8695 show_types, // Boolean indicating if we should show the variable types
8696 show_summary, // Boolean indicating if we should show a summary for the
8697 // current type
8698 verbose, // Verbose output?
8699 depth); // Scope depth for any types that have children
8700 } break;
8701
8702 case clang::Type::Auto: {
8703 clang::QualType elaborated_qual_type =
8704 llvm::cast<clang::AutoType>(qual_type)->getDeducedType();
8705 CompilerType elaborated_clang_type = GetType(elaborated_qual_type);
8706 lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
8707 clang::TypeInfo elaborated_type_info =
8708 getASTContext().getTypeInfo(elaborated_qual_type);
8709 uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
8710
8711 return elaborated_clang_type.DumpValue(
8712 exe_ctx,
8713 s, // Stream to dump to
8714 elaborated_format, // The format with which to display the element
8715 data, // Data buffer containing all bytes for this type
8716 data_byte_offset, // Offset into "data" where to grab value from
8717 elaborated_byte_size, // Size of this type in bytes
8718 bitfield_bit_size, // Bitfield bit size
8719 bitfield_bit_offset, // Bitfield bit offset
8720 show_types, // Boolean indicating if we should show the variable types
8721 show_summary, // Boolean indicating if we should show a summary for the
8722 // current type
8723 verbose, // Verbose output?
8724 depth); // Scope depth for any types that have children
8725 } break;
8726
8727 case clang::Type::Elaborated: {
8728 clang::QualType elaborated_qual_type =
8729 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
8730 CompilerType elaborated_clang_type = GetType(elaborated_qual_type);
8731 lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
8732 clang::TypeInfo elaborated_type_info =
8733 getASTContext().getTypeInfo(elaborated_qual_type);
8734 uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
8735
8736 return elaborated_clang_type.DumpValue(
8737 exe_ctx,
8738 s, // Stream to dump to
8739 elaborated_format, // The format with which to display the element
8740 data, // Data buffer containing all bytes for this type
8741 data_byte_offset, // Offset into "data" where to grab value from
8742 elaborated_byte_size, // Size of this type in bytes
8743 bitfield_bit_size, // Bitfield bit size
8744 bitfield_bit_offset, // Bitfield bit offset
8745 show_types, // Boolean indicating if we should show the variable types
8746 show_summary, // Boolean indicating if we should show a summary for the
8747 // current type
8748 verbose, // Verbose output?
8749 depth); // Scope depth for any types that have children
8750 } break;
8751
8752 case clang::Type::Paren: {
8753 clang::QualType desugar_qual_type =
8754 llvm::cast<clang::ParenType>(qual_type)->desugar();
8755 CompilerType desugar_clang_type = GetType(desugar_qual_type);
8756
8757 lldb::Format desugar_format = desugar_clang_type.GetFormat();
8758 clang::TypeInfo desugar_type_info =
8759 getASTContext().getTypeInfo(desugar_qual_type);
8760 uint64_t desugar_byte_size = desugar_type_info.Width / 8;
8761
8762 return desugar_clang_type.DumpValue(
8763 exe_ctx,
8764 s, // Stream to dump to
8765 desugar_format, // The format with which to display the element
8766 data, // Data buffer containing all bytes for this type
8767 data_byte_offset, // Offset into "data" where to grab value from
8768 desugar_byte_size, // Size of this type in bytes
8769 bitfield_bit_size, // Bitfield bit size
8770 bitfield_bit_offset, // Bitfield bit offset
8771 show_types, // Boolean indicating if we should show the variable types
8772 show_summary, // Boolean indicating if we should show a summary for the
8773 // current type
8774 verbose, // Verbose output?
8775 depth); // Scope depth for any types that have children
8776 } break;
8777
8778 default:
8779 // We are down to a scalar type that we just need to display.
8780 DumpDataExtractor(data, s, data_byte_offset, format, data_byte_size, 1,
8781 UINT32_MAX0xffffffffU, LLDB_INVALID_ADDRESS0xffffffffffffffffULL, bitfield_bit_size,
8782 bitfield_bit_offset);
8783
8784 if (show_summary)
8785 DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
8786 break;
8787 }
8788}
8789
8790static bool DumpEnumValue(const clang::QualType &qual_type, Stream *s,
8791 const DataExtractor &data, lldb::offset_t byte_offset,
8792 size_t byte_size, uint32_t bitfield_bit_offset,
8793 uint32_t bitfield_bit_size) {
8794 const clang::EnumType *enutype =
8795 llvm::cast<clang::EnumType>(qual_type.getTypePtr());
8796 const clang::EnumDecl *enum_decl = enutype->getDecl();
8797 assert(enum_decl)((void)0);
8798 lldb::offset_t offset = byte_offset;
8799 const uint64_t enum_svalue = data.GetMaxS64Bitfield(
8800 &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
8801 bool can_be_bitfield = true;
8802 uint64_t covered_bits = 0;
8803 int num_enumerators = 0;
8804
8805 // Try to find an exact match for the value.
8806 // At the same time, we're applying a heuristic to determine whether we want
8807 // to print this enum as a bitfield. We're likely dealing with a bitfield if
8808 // every enumerator is either a one bit value or a superset of the previous
8809 // enumerators. Also 0 doesn't make sense when the enumerators are used as
8810 // flags.
8811 for (auto *enumerator : enum_decl->enumerators()) {
8812 uint64_t val = enumerator->getInitVal().getSExtValue();
8813 val = llvm::SignExtend64(val, 8*byte_size);
8814 if (llvm::countPopulation(val) != 1 && (val & ~covered_bits) != 0)
8815 can_be_bitfield = false;
8816 covered_bits |= val;
8817 ++num_enumerators;
8818 if (val == enum_svalue) {
8819 // Found an exact match, that's all we need to do.
8820 s->PutCString(enumerator->getNameAsString());
8821 return true;
8822 }
8823 }
8824
8825 // Unsigned values make more sense for flags.
8826 offset = byte_offset;
8827 const uint64_t enum_uvalue = data.GetMaxU64Bitfield(
8828 &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
8829
8830 // No exact match, but we don't think this is a bitfield. Print the value as
8831 // decimal.
8832 if (!can_be_bitfield) {
8833 if (qual_type->isSignedIntegerOrEnumerationType())
8834 s->Printf("%" PRIi64"lli", enum_svalue);
8835 else
8836 s->Printf("%" PRIu64"llu", enum_uvalue);
8837 return true;
8838 }
8839
8840 uint64_t remaining_value = enum_uvalue;
8841 std::vector<std::pair<uint64_t, llvm::StringRef>> values;
8842 values.reserve(num_enumerators);
8843 for (auto *enumerator : enum_decl->enumerators())
8844 if (auto val = enumerator->getInitVal().getZExtValue())
8845 values.emplace_back(val, enumerator->getName());
8846
8847 // Sort in reverse order of the number of the population count, so that in
8848 // `enum {A, B, ALL = A|B }` we visit ALL first. Use a stable sort so that
8849 // A | C where A is declared before C is displayed in this order.
8850 std::stable_sort(values.begin(), values.end(), [](const auto &a, const auto &b) {
8851 return llvm::countPopulation(a.first) > llvm::countPopulation(b.first);
8852 });
8853
8854 for (const auto &val : values) {
8855 if ((remaining_value & val.first) != val.first)
8856 continue;
8857 remaining_value &= ~val.first;
8858 s->PutCString(val.second);
8859 if (remaining_value)
8860 s->PutCString(" | ");
8861 }
8862
8863 // If there is a remainder that is not covered by the value, print it as hex.
8864 if (remaining_value)
8865 s->Printf("0x%" PRIx64"llx", remaining_value);
8866
8867 return true;
8868}
8869
8870bool TypeSystemClang::DumpTypeValue(
8871 lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
8872 const lldb_private::DataExtractor &data, lldb::offset_t byte_offset,
8873 size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
8874 ExecutionContextScope *exe_scope) {
8875 if (!type)
8876 return false;
8877 if (IsAggregateType(type)) {
8878 return false;
8879 } else {
8880 clang::QualType qual_type(GetQualType(type));
8881
8882 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8883
8884 if (type_class == clang::Type::Elaborated) {
8885 qual_type = llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
8886 return DumpTypeValue(qual_type.getAsOpaquePtr(), s, format, data, byte_offset, byte_size,
8887 bitfield_bit_size, bitfield_bit_offset, exe_scope);
8888 }
8889
8890 switch (type_class) {
8891 case clang::Type::Typedef: {
8892 clang::QualType typedef_qual_type =
8893 llvm::cast<clang::TypedefType>(qual_type)
8894 ->getDecl()
8895 ->getUnderlyingType();
8896 CompilerType typedef_clang_type = GetType(typedef_qual_type);
8897 if (format == eFormatDefault)
8898 format = typedef_clang_type.GetFormat();
8899 clang::TypeInfo typedef_type_info =
8900 getASTContext().getTypeInfo(typedef_qual_type);
8901 uint64_t typedef_byte_size = typedef_type_info.Width / 8;
8902
8903 return typedef_clang_type.DumpTypeValue(
8904 s,
8905 format, // The format with which to display the element
8906 data, // Data buffer containing all bytes for this type
8907 byte_offset, // Offset into "data" where to grab value from
8908 typedef_byte_size, // Size of this type in bytes
8909 bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
8910 // treat as a bitfield
8911 bitfield_bit_offset, // Offset in bits of a bitfield value if
8912 // bitfield_bit_size != 0
8913 exe_scope);
8914 } break;
8915
8916 case clang::Type::Enum:
8917 // If our format is enum or default, show the enumeration value as its
8918 // enumeration string value, else just display it as requested.
8919 if ((format == eFormatEnum || format == eFormatDefault) &&
8920 GetCompleteType(type))
8921 return DumpEnumValue(qual_type, s, data, byte_offset, byte_size,
8922 bitfield_bit_offset, bitfield_bit_size);
8923 // format was not enum, just fall through and dump the value as
8924 // requested....
8925 LLVM_FALLTHROUGH[[gnu::fallthrough]];
8926
8927 default:
8928 // We are down to a scalar type that we just need to display.
8929 {
8930 uint32_t item_count = 1;
8931 // A few formats, we might need to modify our size and count for
8932 // depending
8933 // on how we are trying to display the value...
8934 switch (format) {
8935 default:
8936 case eFormatBoolean:
8937 case eFormatBinary:
8938 case eFormatComplex:
8939 case eFormatCString: // NULL terminated C strings
8940 case eFormatDecimal:
8941 case eFormatEnum:
8942 case eFormatHex:
8943 case eFormatHexUppercase:
8944 case eFormatFloat:
8945 case eFormatOctal:
8946 case eFormatOSType:
8947 case eFormatUnsigned:
8948 case eFormatPointer:
8949 case eFormatVectorOfChar:
8950 case eFormatVectorOfSInt8:
8951 case eFormatVectorOfUInt8:
8952 case eFormatVectorOfSInt16:
8953 case eFormatVectorOfUInt16:
8954 case eFormatVectorOfSInt32:
8955 case eFormatVectorOfUInt32:
8956 case eFormatVectorOfSInt64:
8957 case eFormatVectorOfUInt64:
8958 case eFormatVectorOfFloat32:
8959 case eFormatVectorOfFloat64:
8960 case eFormatVectorOfUInt128:
8961 break;
8962
8963 case eFormatChar:
8964 case eFormatCharPrintable:
8965 case eFormatCharArray:
8966 case eFormatBytes:
8967 case eFormatBytesWithASCII:
8968 item_count = byte_size;
8969 byte_size = 1;
8970 break;
8971
8972 case eFormatUnicode16:
8973 item_count = byte_size / 2;
8974 byte_size = 2;
8975 break;
8976
8977 case eFormatUnicode32:
8978 item_count = byte_size / 4;
8979 byte_size = 4;
8980 break;
8981 }
8982 return DumpDataExtractor(data, s, byte_offset, format, byte_size,
8983 item_count, UINT32_MAX0xffffffffU, LLDB_INVALID_ADDRESS0xffffffffffffffffULL,
8984 bitfield_bit_size, bitfield_bit_offset,
8985 exe_scope);
8986 }
8987 break;
8988 }
8989 }
8990 return false;
8991}
8992
8993void TypeSystemClang::DumpSummary(lldb::opaque_compiler_type_t type,
8994 ExecutionContext *exe_ctx, Stream *s,
8995 const lldb_private::DataExtractor &data,
8996 lldb::offset_t data_byte_offset,
8997 size_t data_byte_size) {
8998 uint32_t length = 0;
8999 if (IsCStringType(type, length)) {
9000 if (exe_ctx) {
9001 Process *process = exe_ctx->GetProcessPtr();
9002 if (process) {
9003 lldb::offset_t offset = data_byte_offset;
9004 lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size);
9005 std::vector<uint8_t> buf;
9006 if (length > 0)
9007 buf.resize(length);
9008 else
9009 buf.resize(256);
9010
9011 DataExtractor cstr_data(&buf.front(), buf.size(),
9012 process->GetByteOrder(), 4);
9013 buf.back() = '\0';
9014 size_t bytes_read;
9015 size_t total_cstr_len = 0;
9016 Status error;
9017 while ((bytes_read = process->ReadMemory(pointer_address, &buf.front(),
9018 buf.size(), error)) > 0) {
9019 const size_t len = strlen((const char *)&buf.front());
9020 if (len == 0)
9021 break;
9022 if (total_cstr_len == 0)
9023 s->PutCString(" \"");
9024 DumpDataExtractor(cstr_data, s, 0, lldb::eFormatChar, 1, len,
9025 UINT32_MAX0xffffffffU, LLDB_INVALID_ADDRESS0xffffffffffffffffULL, 0, 0);
9026 total_cstr_len += len;
9027 if (len < buf.size())
9028 break;
9029 pointer_address += total_cstr_len;
9030 }
9031 if (total_cstr_len > 0)
9032 s->PutChar('"');
9033 }
9034 }
9035 }
9036}
9037
9038void TypeSystemClang::DumpTypeDescription(lldb::opaque_compiler_type_t type,
9039 lldb::DescriptionLevel level) {
9040 StreamFile s(stdout(&__sF[1]), false);
9041 DumpTypeDescription(type, &s, level);
9042
9043 CompilerType ct(this, type);
9044 const clang::Type *clang_type = ClangUtil::GetQualType(ct).getTypePtr();
9045 ClangASTMetadata *metadata = GetMetadata(clang_type);
9046 if (metadata) {
9047 metadata->Dump(&s);
9048 }
9049}
9050
9051void TypeSystemClang::DumpTypeDescription(lldb::opaque_compiler_type_t type,
9052 Stream *s,
9053 lldb::DescriptionLevel level) {
9054 if (type) {
9055 clang::QualType qual_type =
9056 RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
9057
9058 llvm::SmallVector<char, 1024> buf;
9059 llvm::raw_svector_ostream llvm_ostrm(buf);
9060
9061 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9062 switch (type_class) {
9063 case clang::Type::ObjCObject:
9064 case clang::Type::ObjCInterface: {
9065 GetCompleteType(type);
9066
9067 auto *objc_class_type =
9068 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
9069 assert(objc_class_type)((void)0);
9070 if (!objc_class_type)
9071 break;
9072 clang::ObjCInterfaceDecl *class_interface_decl =
9073 objc_class_type->getInterface();
9074 if (!class_interface_decl)
9075 break;
9076 if (level == eDescriptionLevelVerbose)
9077 class_interface_decl->dump(llvm_ostrm);
9078 else
9079 class_interface_decl->print(llvm_ostrm,
9080 getASTContext().getPrintingPolicy(),
9081 s->GetIndentLevel());
9082 } break;
9083
9084 case clang::Type::Typedef: {
9085 auto *typedef_type = qual_type->getAs<clang::TypedefType>();
9086 if (!typedef_type)
9087 break;
9088 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
9089 if (level == eDescriptionLevelVerbose)
9090 typedef_decl->dump(llvm_ostrm);
9091 else {
9092 std::string clang_typedef_name(GetTypeNameForDecl(typedef_decl));
9093 if (!clang_typedef_name.empty()) {
9094 s->PutCString("typedef ");
9095 s->PutCString(clang_typedef_name);
9096 }
9097 }
9098 } break;
9099
9100 case clang::Type::Record: {
9101 GetCompleteType(type);
9102
9103 auto *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
9104 const clang::RecordDecl *record_decl = record_type->getDecl();
9105 if (level == eDescriptionLevelVerbose)
9106 record_decl->dump(llvm_ostrm);
9107 else {
9108 if (auto *cxx_record_decl =
9109 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl))
9110 cxx_record_decl->print(llvm_ostrm,
9111 getASTContext().getPrintingPolicy(),
9112 s->GetIndentLevel());
9113 else
9114 record_decl->print(llvm_ostrm, getASTContext().getPrintingPolicy(),
9115 s->GetIndentLevel());
9116 }
9117 } break;
9118
9119 default: {
9120 if (auto *tag_type =
9121 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr())) {
9122 if (clang::TagDecl *tag_decl = tag_type->getDecl()) {
9123 if (level == eDescriptionLevelVerbose)
9124 tag_decl->dump(llvm_ostrm);
9125 else
9126 tag_decl->print(llvm_ostrm, 0);
9127 }
9128 } else {
9129 if (level == eDescriptionLevelVerbose)
9130 qual_type->dump(llvm_ostrm, getASTContext());
9131 else {
9132 std::string clang_type_name(qual_type.getAsString());
9133 if (!clang_type_name.empty())
9134 s->PutCString(clang_type_name);
9135 }
9136 }
9137 }
9138 }
9139
9140 if (buf.size() > 0) {
9141 s->Write(buf.data(), buf.size());
9142 }
9143}
9144}
9145
9146void TypeSystemClang::DumpTypeName(const CompilerType &type) {
9147 if (ClangUtil::IsClangType(type)) {
9148 clang::QualType qual_type(
9149 ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
9150
9151 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9152 switch (type_class) {
9153 case clang::Type::Record: {
9154 const clang::CXXRecordDecl *cxx_record_decl =
9155 qual_type->getAsCXXRecordDecl();
9156 if (cxx_record_decl)
9157 printf("class %s", cxx_record_decl->getName().str().c_str());
9158 } break;
9159
9160 case clang::Type::Enum: {
9161 clang::EnumDecl *enum_decl =
9162 llvm::cast<clang::EnumType>(qual_type)->getDecl();
9163 if (enum_decl) {
9164 printf("enum %s", enum_decl->getName().str().c_str());
9165 }
9166 } break;
9167
9168 case clang::Type::ObjCObject:
9169 case clang::Type::ObjCInterface: {
9170 const clang::ObjCObjectType *objc_class_type =
9171 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
9172 if (objc_class_type) {
9173 clang::ObjCInterfaceDecl *class_interface_decl =
9174 objc_class_type->getInterface();
9175 // We currently can't complete objective C types through the newly
9176 // added ASTContext because it only supports TagDecl objects right
9177 // now...
9178 if (class_interface_decl)
9179 printf("@class %s", class_interface_decl->getName().str().c_str());
9180 }
9181 } break;
9182
9183 case clang::Type::Typedef:
9184 printf("typedef %s", llvm::cast<clang::TypedefType>(qual_type)
9185 ->getDecl()
9186 ->getName()
9187 .str()
9188 .c_str());
9189 break;
9190
9191 case clang::Type::Auto:
9192 printf("auto ");
9193 return DumpTypeName(CompilerType(type.GetTypeSystem(),
9194 llvm::cast<clang::AutoType>(qual_type)
9195 ->getDeducedType()
9196 .getAsOpaquePtr()));
9197
9198 case clang::Type::Elaborated:
9199 printf("elaborated ");
9200 return DumpTypeName(CompilerType(
9201 type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)
9202 ->getNamedType()
9203 .getAsOpaquePtr()));
9204
9205 case clang::Type::Paren:
9206 printf("paren ");
9207 return DumpTypeName(CompilerType(
9208 type.GetTypeSystem(),
9209 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
9210
9211 default:
9212 printf("TypeSystemClang::DumpTypeName() type_class = %u", type_class);
9213 break;
9214 }
9215 }
9216}
9217
9218clang::ClassTemplateDecl *TypeSystemClang::ParseClassTemplateDecl(
9219 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
9220 lldb::AccessType access_type, const char *parent_name, int tag_decl_kind,
9221 const TypeSystemClang::TemplateParameterInfos &template_param_infos) {
9222 if (template_param_infos.IsValid()) {
9223 std::string template_basename(parent_name);
9224 template_basename.erase(template_basename.find('<'));
9225
9226 return CreateClassTemplateDecl(decl_ctx, owning_module, access_type,
9227 template_basename.c_str(), tag_decl_kind,
9228 template_param_infos);
9229 }
9230 return nullptr;
9231}
9232
9233void TypeSystemClang::CompleteTagDecl(clang::TagDecl *decl) {
9234 SymbolFile *sym_file = GetSymbolFile();
9235 if (sym_file) {
9236 CompilerType clang_type = GetTypeForDecl(decl);
9237 if (clang_type)
9238 sym_file->CompleteType(clang_type);
9239 }
9240}
9241
9242void TypeSystemClang::CompleteObjCInterfaceDecl(
9243 clang::ObjCInterfaceDecl *decl) {
9244 SymbolFile *sym_file = GetSymbolFile();
9245 if (sym_file) {
9246 CompilerType clang_type = GetTypeForDecl(decl);
9247 if (clang_type)
9248 sym_file->CompleteType(clang_type);
9249 }
9250}
9251
9252DWARFASTParser *TypeSystemClang::GetDWARFParser() {
9253 if (!m_dwarf_ast_parser_up)
9254 m_dwarf_ast_parser_up = std::make_unique<DWARFASTParserClang>(*this);
9255 return m_dwarf_ast_parser_up.get();
9256}
9257
9258PDBASTParser *TypeSystemClang::GetPDBParser() {
9259 if (!m_pdb_ast_parser_up)
9260 m_pdb_ast_parser_up = std::make_unique<PDBASTParser>(*this);
9261 return m_pdb_ast_parser_up.get();
9262}
9263
9264bool TypeSystemClang::LayoutRecordType(
9265 const clang::RecordDecl *record_decl, uint64_t &bit_size,
9266 uint64_t &alignment,
9267 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
9268 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
9269 &base_offsets,
9270 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
9271 &vbase_offsets) {
9272 lldb_private::ClangASTImporter *importer = nullptr;
9273 if (m_dwarf_ast_parser_up)
9274 importer = &m_dwarf_ast_parser_up->GetClangASTImporter();
9275 if (!importer && m_pdb_ast_parser_up)
9276 importer = &m_pdb_ast_parser_up->GetClangASTImporter();
9277 if (!importer)
9278 return false;
9279
9280 return importer->LayoutRecordType(record_decl, bit_size, alignment,
9281 field_offsets, base_offsets, vbase_offsets);
9282}
9283
9284// CompilerDecl override functions
9285
9286ConstString TypeSystemClang::DeclGetName(void *opaque_decl) {
9287 if (opaque_decl) {
9288 clang::NamedDecl *nd =
9289 llvm::dyn_cast<NamedDecl>((clang::Decl *)opaque_decl);
9290 if (nd != nullptr)
9291 return ConstString(nd->getDeclName().getAsString());
9292 }
9293 return ConstString();
9294}
9295
9296ConstString TypeSystemClang::DeclGetMangledName(void *opaque_decl) {
9297 if (opaque_decl) {
9298 clang::NamedDecl *nd =
9299 llvm::dyn_cast<clang::NamedDecl>((clang::Decl *)opaque_decl);
9300 if (nd != nullptr && !llvm::isa<clang::ObjCMethodDecl>(nd)) {
9301 clang::MangleContext *mc = getMangleContext();
9302 if (mc && mc->shouldMangleCXXName(nd)) {
9303 llvm::SmallVector<char, 1024> buf;
9304 llvm::raw_svector_ostream llvm_ostrm(buf);
9305 if (llvm::isa<clang::CXXConstructorDecl>(nd)) {
9306 mc->mangleName(
9307 clang::GlobalDecl(llvm::dyn_cast<clang::CXXConstructorDecl>(nd),
9308 Ctor_Complete),
9309 llvm_ostrm);
9310 } else if (llvm::isa<clang::CXXDestructorDecl>(nd)) {
9311 mc->mangleName(
9312 clang::GlobalDecl(llvm::dyn_cast<clang::CXXDestructorDecl>(nd),
9313 Dtor_Complete),
9314 llvm_ostrm);
9315 } else {
9316 mc->mangleName(nd, llvm_ostrm);
9317 }
9318 if (buf.size() > 0)
9319 return ConstString(buf.data(), buf.size());
9320 }
9321 }
9322 }
9323 return ConstString();
9324}
9325
9326CompilerDeclContext TypeSystemClang::DeclGetDeclContext(void *opaque_decl) {
9327 if (opaque_decl)
9328 return CreateDeclContext(((clang::Decl *)opaque_decl)->getDeclContext());
9329 return CompilerDeclContext();
9330}
9331
9332CompilerType TypeSystemClang::DeclGetFunctionReturnType(void *opaque_decl) {
9333 if (clang::FunctionDecl *func_decl =
9334 llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl))
9335 return GetType(func_decl->getReturnType());
9336 if (clang::ObjCMethodDecl *objc_method =
9337 llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl))
9338 return GetType(objc_method->getReturnType());
9339 else
9340 return CompilerType();
9341}
9342
9343size_t TypeSystemClang::DeclGetFunctionNumArguments(void *opaque_decl) {
9344 if (clang::FunctionDecl *func_decl =
9345 llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl))
9346 return func_decl->param_size();
9347 if (clang::ObjCMethodDecl *objc_method =
9348 llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl))
9349 return objc_method->param_size();
9350 else
9351 return 0;
9352}
9353
9354CompilerType TypeSystemClang::DeclGetFunctionArgumentType(void *opaque_decl,
9355 size_t idx) {
9356 if (clang::FunctionDecl *func_decl =
9357 llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl)) {
9358 if (idx < func_decl->param_size()) {
9359 ParmVarDecl *var_decl = func_decl->getParamDecl(idx);
9360 if (var_decl)
9361 return GetType(var_decl->getOriginalType());
9362 }
9363 } else if (clang::ObjCMethodDecl *objc_method =
9364 llvm::dyn_cast<clang::ObjCMethodDecl>(
9365 (clang::Decl *)opaque_decl)) {
9366 if (idx < objc_method->param_size())
9367 return GetType(objc_method->parameters()[idx]->getOriginalType());
9368 }
9369 return CompilerType();
9370}
9371
9372// CompilerDeclContext functions
9373
9374std::vector<CompilerDecl> TypeSystemClang::DeclContextFindDeclByName(
9375 void *opaque_decl_ctx, ConstString name, const bool ignore_using_decls) {
9376 std::vector<CompilerDecl> found_decls;
9377 SymbolFile *symbol_file = GetSymbolFile();
9378 if (opaque_decl_ctx && symbol_file) {
9379 DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx;
9380 std::set<DeclContext *> searched;
9381 std::multimap<DeclContext *, DeclContext *> search_queue;
9382
9383 for (clang::DeclContext *decl_context = root_decl_ctx;
9384 decl_context != nullptr && found_decls.empty();
9385 decl_context = decl_context->getParent()) {
9386 search_queue.insert(std::make_pair(decl_context, decl_context));
9387
9388 for (auto it = search_queue.find(decl_context); it != search_queue.end();
9389 it++) {
9390 if (!searched.insert(it->second).second)
9391 continue;
9392 symbol_file->ParseDeclsForContext(
9393 CreateDeclContext(it->second));
9394
9395 for (clang::Decl *child : it->second->decls()) {
9396 if (clang::UsingDirectiveDecl *ud =
9397 llvm::dyn_cast<clang::UsingDirectiveDecl>(child)) {
9398 if (ignore_using_decls)
9399 continue;
9400 clang::DeclContext *from = ud->getCommonAncestor();
9401 if (searched.find(ud->getNominatedNamespace()) == searched.end())
9402 search_queue.insert(
9403 std::make_pair(from, ud->getNominatedNamespace()));
9404 } else if (clang::UsingDecl *ud =
9405 llvm::dyn_cast<clang::UsingDecl>(child)) {
9406 if (ignore_using_decls)
9407 continue;
9408 for (clang::UsingShadowDecl *usd : ud->shadows()) {
9409 clang::Decl *target = usd->getTargetDecl();
9410 if (clang::NamedDecl *nd =
9411 llvm::dyn_cast<clang::NamedDecl>(target)) {
9412 IdentifierInfo *ii = nd->getIdentifier();
9413 if (ii != nullptr &&
9414 ii->getName().equals(name.AsCString(nullptr)))
9415 found_decls.push_back(GetCompilerDecl(nd));
9416 }
9417 }
9418 } else if (clang::NamedDecl *nd =
9419 llvm::dyn_cast<clang::NamedDecl>(child)) {
9420 IdentifierInfo *ii = nd->getIdentifier();
9421 if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
9422 found_decls.push_back(GetCompilerDecl(nd));
9423 }
9424 }
9425 }
9426 }
9427 }
9428 return found_decls;
9429}
9430
9431// Look for child_decl_ctx's lookup scope in frame_decl_ctx and its parents,
9432// and return the number of levels it took to find it, or
9433// LLDB_INVALID_DECL_LEVEL if not found. If the decl was imported via a using
9434// declaration, its name and/or type, if set, will be used to check that the
9435// decl found in the scope is a match.
9436//
9437// The optional name is required by languages (like C++) to handle using
9438// declarations like:
9439//
9440// void poo();
9441// namespace ns {
9442// void foo();
9443// void goo();
9444// }
9445// void bar() {
9446// using ns::foo;
9447// // CountDeclLevels returns 0 for 'foo', 1 for 'poo', and
9448// // LLDB_INVALID_DECL_LEVEL for 'goo'.
9449// }
9450//
9451// The optional type is useful in the case that there's a specific overload
9452// that we're looking for that might otherwise be shadowed, like:
9453//
9454// void foo(int);
9455// namespace ns {
9456// void foo();
9457// }
9458// void bar() {
9459// using ns::foo;
9460// // CountDeclLevels returns 0 for { 'foo', void() },
9461// // 1 for { 'foo', void(int) }, and
9462// // LLDB_INVALID_DECL_LEVEL for { 'foo', void(int, int) }.
9463// }
9464//
9465// NOTE: Because file statics are at the TranslationUnit along with globals, a
9466// function at file scope will return the same level as a function at global
9467// scope. Ideally we'd like to treat the file scope as an additional scope just
9468// below the global scope. More work needs to be done to recognise that, if
9469// the decl we're trying to look up is static, we should compare its source
9470// file with that of the current scope and return a lower number for it.
9471uint32_t TypeSystemClang::CountDeclLevels(clang::DeclContext *frame_decl_ctx,
9472 clang::DeclContext *child_decl_ctx,
9473 ConstString *child_name,
9474 CompilerType *child_type) {
9475 SymbolFile *symbol_file = GetSymbolFile();
9476 if (frame_decl_ctx && symbol_file) {
9477 std::set<DeclContext *> searched;
9478 std::multimap<DeclContext *, DeclContext *> search_queue;
9479
9480 // Get the lookup scope for the decl we're trying to find.
9481 clang::DeclContext *parent_decl_ctx = child_decl_ctx->getParent();
9482
9483 // Look for it in our scope's decl context and its parents.
9484 uint32_t level = 0;
9485 for (clang::DeclContext *decl_ctx = frame_decl_ctx; decl_ctx != nullptr;
9486 decl_ctx = decl_ctx->getParent()) {
9487 if (!decl_ctx->isLookupContext())
9488 continue;
9489 if (decl_ctx == parent_decl_ctx)
9490 // Found it!
9491 return level;
9492 search_queue.insert(std::make_pair(decl_ctx, decl_ctx));
9493 for (auto it = search_queue.find(decl_ctx); it != search_queue.end();
9494 it++) {
9495 if (searched.find(it->second) != searched.end())
9496 continue;
9497
9498 // Currently DWARF has one shared translation unit for all Decls at top
9499 // level, so this would erroneously find using statements anywhere. So
9500 // don't look at the top-level translation unit.
9501 // TODO fix this and add a testcase that depends on it.
9502
9503 if (llvm::isa<clang::TranslationUnitDecl>(it->second))
9504 continue;
9505
9506 searched.insert(it->second);
9507 symbol_file->ParseDeclsForContext(
9508 CreateDeclContext(it->second));
9509
9510 for (clang::Decl *child : it->second->decls()) {
9511 if (clang::UsingDirectiveDecl *ud =
9512 llvm::dyn_cast<clang::UsingDirectiveDecl>(child)) {
9513 clang::DeclContext *ns = ud->getNominatedNamespace();
9514 if (ns == parent_decl_ctx)
9515 // Found it!
9516 return level;
9517 clang::DeclContext *from = ud->getCommonAncestor();
9518 if (searched.find(ns) == searched.end())
9519 search_queue.insert(std::make_pair(from, ns));
9520 } else if (child_name) {
9521 if (clang::UsingDecl *ud =
9522 llvm::dyn_cast<clang::UsingDecl>(child)) {
9523 for (clang::UsingShadowDecl *usd : ud->shadows()) {
9524 clang::Decl *target = usd->getTargetDecl();
9525 clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target);
9526 if (!nd)
9527 continue;
9528 // Check names.
9529 IdentifierInfo *ii = nd->getIdentifier();
9530 if (ii == nullptr ||
9531 !ii->getName().equals(child_name->AsCString(nullptr)))
9532 continue;
9533 // Check types, if one was provided.
9534 if (child_type) {
9535 CompilerType clang_type = GetTypeForDecl(nd);
9536 if (!AreTypesSame(clang_type, *child_type,
9537 /*ignore_qualifiers=*/true))
9538 continue;
9539 }
9540 // Found it!
9541 return level;
9542 }
9543 }
9544 }
9545 }
9546 }
9547 ++level;
9548 }
9549 }
9550 return LLDB_INVALID_DECL_LEVEL0xffffffffU;
9551}
9552
9553ConstString TypeSystemClang::DeclContextGetName(void *opaque_decl_ctx) {
9554 if (opaque_decl_ctx) {
9555 clang::NamedDecl *named_decl =
9556 llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
9557 if (named_decl)
9558 return ConstString(named_decl->getName());
9559 }
9560 return ConstString();
9561}
9562
9563ConstString
9564TypeSystemClang::DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) {
9565 if (opaque_decl_ctx) {
9566 clang::NamedDecl *named_decl =
9567 llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
9568 if (named_decl)
9569 return ConstString(GetTypeNameForDecl(named_decl));
9570 }
9571 return ConstString();
9572}
9573
9574bool TypeSystemClang::DeclContextIsClassMethod(
9575 void *opaque_decl_ctx, lldb::LanguageType *language_ptr,
9576 bool *is_instance_method_ptr, ConstString *language_object_name_ptr) {
9577 if (opaque_decl_ctx) {
9578 clang::DeclContext *decl_ctx = (clang::DeclContext *)opaque_decl_ctx;
9579 if (ObjCMethodDecl *objc_method =
9580 llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) {
9581 if (is_instance_method_ptr)
9582 *is_instance_method_ptr = objc_method->isInstanceMethod();
9583 if (language_ptr)
9584 *language_ptr = eLanguageTypeObjC;
9585 if (language_object_name_ptr)
9586 language_object_name_ptr->SetCString("self");
9587 return true;
9588 } else if (CXXMethodDecl *cxx_method =
9589 llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) {
9590 if (is_instance_method_ptr)
9591 *is_instance_method_ptr = cxx_method->isInstance();
9592 if (language_ptr)
9593 *language_ptr = eLanguageTypeC_plus_plus;
9594 if (language_object_name_ptr)
9595 language_object_name_ptr->SetCString("this");
9596 return true;
9597 } else if (clang::FunctionDecl *function_decl =
9598 llvm::dyn_cast<clang::FunctionDecl>(decl_ctx)) {
9599 ClangASTMetadata *metadata = GetMetadata(function_decl);
9600 if (metadata && metadata->HasObjectPtr()) {
9601 if (is_instance_method_ptr)
9602 *is_instance_method_ptr = true;
9603 if (language_ptr)
9604 *language_ptr = eLanguageTypeObjC;
9605 if (language_object_name_ptr)
9606 language_object_name_ptr->SetCString(metadata->GetObjectPtrName());
9607 return true;
9608 }
9609 }
9610 }
9611 return false;
9612}
9613
9614bool TypeSystemClang::DeclContextIsContainedInLookup(
9615 void *opaque_decl_ctx, void *other_opaque_decl_ctx) {
9616 auto *decl_ctx = (clang::DeclContext *)opaque_decl_ctx;
9617 auto *other = (clang::DeclContext *)other_opaque_decl_ctx;
9618
9619 do {
9620 // A decl context always includes its own contents in its lookup.
9621 if (decl_ctx == other)
9622 return true;
9623
9624 // If we have an inline namespace, then the lookup of the parent context
9625 // also includes the inline namespace contents.
9626 } while (other->isInlineNamespace() && (other = other->getParent()));
9627
9628 return false;
9629}
9630
9631static bool IsClangDeclContext(const CompilerDeclContext &dc) {
9632 return dc.IsValid() && isa<TypeSystemClang>(dc.GetTypeSystem());
9633}
9634
9635clang::DeclContext *
9636TypeSystemClang::DeclContextGetAsDeclContext(const CompilerDeclContext &dc) {
9637 if (IsClangDeclContext(dc))
9638 return (clang::DeclContext *)dc.GetOpaqueDeclContext();
9639 return nullptr;
9640}
9641
9642ObjCMethodDecl *
9643TypeSystemClang::DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc) {
9644 if (IsClangDeclContext(dc))
9645 return llvm::dyn_cast<clang::ObjCMethodDecl>(
9646 (clang::DeclContext *)dc.GetOpaqueDeclContext());
9647 return nullptr;
9648}
9649
9650CXXMethodDecl *
9651TypeSystemClang::DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc) {
9652 if (IsClangDeclContext(dc))
9653 return llvm::dyn_cast<clang::CXXMethodDecl>(
9654 (clang::DeclContext *)dc.GetOpaqueDeclContext());
9655 return nullptr;
9656}
9657
9658clang::FunctionDecl *
9659TypeSystemClang::DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc) {
9660 if (IsClangDeclContext(dc))
9661 return llvm::dyn_cast<clang::FunctionDecl>(
9662 (clang::DeclContext *)dc.GetOpaqueDeclContext());
9663 return nullptr;
9664}
9665
9666clang::NamespaceDecl *
9667TypeSystemClang::DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc) {
9668 if (IsClangDeclContext(dc))
9669 return llvm::dyn_cast<clang::NamespaceDecl>(
9670 (clang::DeclContext *)dc.GetOpaqueDeclContext());
9671 return nullptr;
9672}
9673
9674ClangASTMetadata *
9675TypeSystemClang::DeclContextGetMetaData(const CompilerDeclContext &dc,
9676 const Decl *object) {
9677 TypeSystemClang *ast = llvm::cast<TypeSystemClang>(dc.GetTypeSystem());
9678 return ast->GetMetadata(object);
9679}
9680
9681clang::ASTContext *
9682TypeSystemClang::DeclContextGetTypeSystemClang(const CompilerDeclContext &dc) {
9683 TypeSystemClang *ast =
9684 llvm::dyn_cast_or_null<TypeSystemClang>(dc.GetTypeSystem());
9685 if (ast)
9686 return &ast->getASTContext();
9687 return nullptr;
9688}
9689
9690namespace {
9691/// A specialized scratch AST used within ScratchTypeSystemClang.
9692/// These are the ASTs backing the different IsolatedASTKinds. They behave
9693/// like a normal ScratchTypeSystemClang but they don't own their own
9694/// persistent storage or target reference.
9695class SpecializedScratchAST : public TypeSystemClang {
9696public:
9697 /// \param name The display name of the TypeSystemClang instance.
9698 /// \param triple The triple used for the TypeSystemClang instance.
9699 /// \param ast_source The ClangASTSource that should be used to complete
9700 /// type information.
9701 SpecializedScratchAST(llvm::StringRef name, llvm::Triple triple,
9702 std::unique_ptr<ClangASTSource> ast_source)
9703 : TypeSystemClang(name, triple),
9704 m_scratch_ast_source_up(std::move(ast_source)) {
9705 // Setup the ClangASTSource to complete this AST.
9706 m_scratch_ast_source_up->InstallASTContext(*this);
9707 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(
9708 m_scratch_ast_source_up->CreateProxy());
9709 SetExternalSource(proxy_ast_source);
9710 }
9711
9712 /// The ExternalASTSource that performs lookups and completes types.
9713 std::unique_ptr<ClangASTSource> m_scratch_ast_source_up;
9714};
9715} // namespace
9716
9717char ScratchTypeSystemClang::ID;
9718const llvm::NoneType ScratchTypeSystemClang::DefaultAST = llvm::None;
9719
9720ScratchTypeSystemClang::ScratchTypeSystemClang(Target &target,
9721 llvm::Triple triple)
9722 : TypeSystemClang("scratch ASTContext", triple), m_triple(triple),
9723 m_target_wp(target.shared_from_this()),
9724 m_persistent_variables(
9725 new ClangPersistentVariables(target.shared_from_this())) {
9726 m_scratch_ast_source_up = CreateASTSource();
9727 m_scratch_ast_source_up->InstallASTContext(*this);
9728 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(
9729 m_scratch_ast_source_up->CreateProxy());
9730 SetExternalSource(proxy_ast_source);
9731}
9732
9733void ScratchTypeSystemClang::Finalize() {
9734 TypeSystemClang::Finalize();
9735 m_scratch_ast_source_up.reset();
9736}
9737
9738TypeSystemClang *
9739ScratchTypeSystemClang::GetForTarget(Target &target,
9740 llvm::Optional<IsolatedASTKind> ast_kind,
9741 bool create_on_demand) {
9742 auto type_system_or_err = target.GetScratchTypeSystemForLanguage(
9743 lldb::eLanguageTypeC, create_on_demand);
9744 if (auto err = type_system_or_err.takeError()) {
9745 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 22))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, __func__, "Couldn't get scratch TypeSystemClang"); } else ::
llvm::consumeError(::std::move(error_private)); } while (0)
9746 std::move(err), "Couldn't get scratch TypeSystemClang")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 22))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp"
, __func__, "Couldn't get scratch TypeSystemClang"); } else ::
llvm::consumeError(::std::move(error_private)); } while (0)
;
9747 return nullptr;
9748 }
9749 ScratchTypeSystemClang &scratch_ast =
9750 llvm::cast<ScratchTypeSystemClang>(type_system_or_err.get());
9751 // If no dedicated sub-AST was requested, just return the main AST.
9752 if (ast_kind == DefaultAST)
9753 return &scratch_ast;
9754 // Search the sub-ASTs.
9755 return &scratch_ast.GetIsolatedAST(*ast_kind);
9756}
9757
9758UserExpression *ScratchTypeSystemClang::GetUserExpression(
9759 llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
9760 Expression::ResultType desired_type,
9761 const EvaluateExpressionOptions &options, ValueObject *ctx_obj) {
9762 TargetSP target_sp = m_target_wp.lock();
9763 if (!target_sp)
9764 return nullptr;
9765
9766 return new ClangUserExpression(*target_sp.get(), expr, prefix, language,
9767 desired_type, options, ctx_obj);
9768}
9769
9770FunctionCaller *ScratchTypeSystemClang::GetFunctionCaller(
9771 const CompilerType &return_type, const Address &function_address,
9772 const ValueList &arg_value_list, const char *name) {
9773 TargetSP target_sp = m_target_wp.lock();
9774 if (!target_sp)
9775 return nullptr;
9776
9777 Process *process = target_sp->GetProcessSP().get();
9778 if (!process)
9779 return nullptr;
9780
9781 return new ClangFunctionCaller(*process, return_type, function_address,
9782 arg_value_list, name);
9783}
9784
9785std::unique_ptr<UtilityFunction>
9786ScratchTypeSystemClang::CreateUtilityFunction(std::string text,
9787 std::string name) {
9788 TargetSP target_sp = m_target_wp.lock();
9789 if (!target_sp)
9790 return {};
9791
9792 return std::make_unique<ClangUtilityFunction>(
9793 *target_sp.get(), std::move(text), std::move(name),
9794 target_sp->GetDebugUtilityExpression());
9795}
9796
9797PersistentExpressionState *
9798ScratchTypeSystemClang::GetPersistentExpressionState() {
9799 return m_persistent_variables.get();
9800}
9801
9802void ScratchTypeSystemClang::ForgetSource(ASTContext *src_ctx,
9803 ClangASTImporter &importer) {
9804 // Remove it as a source from the main AST.
9805 importer.ForgetSource(&getASTContext(), src_ctx);
9806 // Remove it as a source from all created sub-ASTs.
9807 for (const auto &a : m_isolated_asts)
9808 importer.ForgetSource(&a.second->getASTContext(), src_ctx);
9809}
9810
9811std::unique_ptr<ClangASTSource> ScratchTypeSystemClang::CreateASTSource() {
9812 return std::make_unique<ClangASTSource>(
9813 m_target_wp.lock()->shared_from_this(),
9814 m_persistent_variables->GetClangASTImporter());
9815}
9816
9817static llvm::StringRef
9818GetSpecializedASTName(ScratchTypeSystemClang::IsolatedASTKind feature) {
9819 switch (feature) {
9820 case ScratchTypeSystemClang::IsolatedASTKind::CppModules:
9821 return "scratch ASTContext for C++ module types";
9822 }
9823 llvm_unreachable("Unimplemented ASTFeature kind?")__builtin_unreachable();
9824}
9825
9826TypeSystemClang &ScratchTypeSystemClang::GetIsolatedAST(
9827 ScratchTypeSystemClang::IsolatedASTKind feature) {
9828 auto found_ast = m_isolated_asts.find(feature);
9829 if (found_ast != m_isolated_asts.end())
9830 return *found_ast->second;
9831
9832 // Couldn't find the requested sub-AST, so create it now.
9833 std::unique_ptr<TypeSystemClang> new_ast;
9834 new_ast.reset(new SpecializedScratchAST(GetSpecializedASTName(feature),
9835 m_triple, CreateASTSource()));
9836 m_isolated_asts[feature] = std::move(new_ast);
9837 return *m_isolated_asts[feature];
9838}

/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/clang/include/clang/AST/Decl.h

1//===- Decl.h - Classes for representing declarations -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the Decl subclasses.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_DECL_H
14#define LLVM_CLANG_AST_DECL_H
15
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTContextAllocate.h"
18#include "clang/AST/DeclAccessPair.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/ExternalASTSource.h"
22#include "clang/AST/NestedNameSpecifier.h"
23#include "clang/AST/Redeclarable.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/AddressSpaces.h"
26#include "clang/Basic/Diagnostic.h"
27#include "clang/Basic/IdentifierTable.h"
28#include "clang/Basic/LLVM.h"
29#include "clang/Basic/Linkage.h"
30#include "clang/Basic/OperatorKinds.h"
31#include "clang/Basic/PartialDiagnostic.h"
32#include "clang/Basic/PragmaKinds.h"
33#include "clang/Basic/SourceLocation.h"
34#include "clang/Basic/Specifiers.h"
35#include "clang/Basic/Visibility.h"
36#include "llvm/ADT/APSInt.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/TrailingObjects.h"
46#include <cassert>
47#include <cstddef>
48#include <cstdint>
49#include <string>
50#include <utility>
51
52namespace clang {
53
54class ASTContext;
55struct ASTTemplateArgumentListInfo;
56class Attr;
57class CompoundStmt;
58class DependentFunctionTemplateSpecializationInfo;
59class EnumDecl;
60class Expr;
61class FunctionTemplateDecl;
62class FunctionTemplateSpecializationInfo;
63class FunctionTypeLoc;
64class LabelStmt;
65class MemberSpecializationInfo;
66class Module;
67class NamespaceDecl;
68class ParmVarDecl;
69class RecordDecl;
70class Stmt;
71class StringLiteral;
72class TagDecl;
73class TemplateArgumentList;
74class TemplateArgumentListInfo;
75class TemplateParameterList;
76class TypeAliasTemplateDecl;
77class TypeLoc;
78class UnresolvedSetImpl;
79class VarTemplateDecl;
80
81/// The top declaration context.
82class TranslationUnitDecl : public Decl,
83 public DeclContext,
84 public Redeclarable<TranslationUnitDecl> {
85 using redeclarable_base = Redeclarable<TranslationUnitDecl>;
86
87 TranslationUnitDecl *getNextRedeclarationImpl() override {
88 return getNextRedeclaration();
89 }
90
91 TranslationUnitDecl *getPreviousDeclImpl() override {
92 return getPreviousDecl();
93 }
94
95 TranslationUnitDecl *getMostRecentDeclImpl() override {
96 return getMostRecentDecl();
97 }
98
99 ASTContext &Ctx;
100
101 /// The (most recently entered) anonymous namespace for this
102 /// translation unit, if one has been created.
103 NamespaceDecl *AnonymousNamespace = nullptr;
104
105 explicit TranslationUnitDecl(ASTContext &ctx);
106
107 virtual void anchor();
108
109public:
110 using redecl_range = redeclarable_base::redecl_range;
111 using redecl_iterator = redeclarable_base::redecl_iterator;
112
113 using redeclarable_base::getMostRecentDecl;
114 using redeclarable_base::getPreviousDecl;
115 using redeclarable_base::isFirstDecl;
116 using redeclarable_base::redecls;
117 using redeclarable_base::redecls_begin;
118 using redeclarable_base::redecls_end;
119
120 ASTContext &getASTContext() const { return Ctx; }
121
122 NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
123 void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
124
125 static TranslationUnitDecl *Create(ASTContext &C);
126
127 // Implement isa/cast/dyncast/etc.
128 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
129 static bool classofKind(Kind K) { return K == TranslationUnit; }
130 static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
131 return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
132 }
133 static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
134 return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
135 }
136};
137
138/// Represents a `#pragma comment` line. Always a child of
139/// TranslationUnitDecl.
140class PragmaCommentDecl final
141 : public Decl,
142 private llvm::TrailingObjects<PragmaCommentDecl, char> {
143 friend class ASTDeclReader;
144 friend class ASTDeclWriter;
145 friend TrailingObjects;
146
147 PragmaMSCommentKind CommentKind;
148
149 PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,
150 PragmaMSCommentKind CommentKind)
151 : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
152
153 virtual void anchor();
154
155public:
156 static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,
157 SourceLocation CommentLoc,
158 PragmaMSCommentKind CommentKind,
159 StringRef Arg);
160 static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
161 unsigned ArgSize);
162
163 PragmaMSCommentKind getCommentKind() const { return CommentKind; }
164
165 StringRef getArg() const { return getTrailingObjects<char>(); }
166
167 // Implement isa/cast/dyncast/etc.
168 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
169 static bool classofKind(Kind K) { return K == PragmaComment; }
170};
171
172/// Represents a `#pragma detect_mismatch` line. Always a child of
173/// TranslationUnitDecl.
174class PragmaDetectMismatchDecl final
175 : public Decl,
176 private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
177 friend class ASTDeclReader;
178 friend class ASTDeclWriter;
179 friend TrailingObjects;
180
181 size_t ValueStart;
182
183 PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,
184 size_t ValueStart)
185 : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
186
187 virtual void anchor();
188
189public:
190 static PragmaDetectMismatchDecl *Create(const ASTContext &C,
191 TranslationUnitDecl *DC,
192 SourceLocation Loc, StringRef Name,
193 StringRef Value);
194 static PragmaDetectMismatchDecl *
195 CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);
196
197 StringRef getName() const { return getTrailingObjects<char>(); }
198 StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }
199
200 // Implement isa/cast/dyncast/etc.
201 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
202 static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
203};
204
205/// Declaration context for names declared as extern "C" in C++. This
206/// is neither the semantic nor lexical context for such declarations, but is
207/// used to check for conflicts with other extern "C" declarations. Example:
208///
209/// \code
210/// namespace N { extern "C" void f(); } // #1
211/// void N::f() {} // #2
212/// namespace M { extern "C" void f(); } // #3
213/// \endcode
214///
215/// The semantic context of #1 is namespace N and its lexical context is the
216/// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
217/// context is the TU. However, both declarations are also visible in the
218/// extern "C" context.
219///
220/// The declaration at #3 finds it is a redeclaration of \c N::f through
221/// lookup in the extern "C" context.
222class ExternCContextDecl : public Decl, public DeclContext {
223 explicit ExternCContextDecl(TranslationUnitDecl *TU)
224 : Decl(ExternCContext, TU, SourceLocation()),
225 DeclContext(ExternCContext) {}
226
227 virtual void anchor();
228
229public:
230 static ExternCContextDecl *Create(const ASTContext &C,
231 TranslationUnitDecl *TU);
232
233 // Implement isa/cast/dyncast/etc.
234 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
235 static bool classofKind(Kind K) { return K == ExternCContext; }
236 static DeclContext *castToDeclContext(const ExternCContextDecl *D) {
237 return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
238 }
239 static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {
240 return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
241 }
242};
243
244/// This represents a decl that may have a name. Many decls have names such
245/// as ObjCMethodDecl, but not \@class, etc.
246///
247/// Note that not every NamedDecl is actually named (e.g., a struct might
248/// be anonymous), and not every name is an identifier.
249class NamedDecl : public Decl {
250 /// The name of this declaration, which is typically a normal
251 /// identifier but may also be a special kind of name (C++
252 /// constructor, Objective-C selector, etc.)
253 DeclarationName Name;
254
255 virtual void anchor();
256
257private:
258 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY__attribute__((__pure__));
259
260protected:
261 NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
262 : Decl(DK, DC, L), Name(N) {}
263
264public:
265 /// Get the identifier that names this declaration, if there is one.
266 ///
267 /// This will return NULL if this declaration has no name (e.g., for
268 /// an unnamed class) or if the name is a special name (C++ constructor,
269 /// Objective-C selector, etc.).
270 IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }
271
272 /// Get the name of identifier for this declaration as a StringRef.
273 ///
274 /// This requires that the declaration have a name and that it be a simple
275 /// identifier.
276 StringRef getName() const {
277 assert(Name.isIdentifier() && "Name is not a simple identifier")((void)0);
278 return getIdentifier() ? getIdentifier()->getName() : "";
279 }
280
281 /// Get a human-readable name for the declaration, even if it is one of the
282 /// special kinds of names (C++ constructor, Objective-C selector, etc).
283 ///
284 /// Creating this name requires expensive string manipulation, so it should
285 /// be called only when performance doesn't matter. For simple declarations,
286 /// getNameAsCString() should suffice.
287 //
288 // FIXME: This function should be renamed to indicate that it is not just an
289 // alternate form of getName(), and clients should move as appropriate.
290 //
291 // FIXME: Deprecated, move clients to getName().
292 std::string getNameAsString() const { return Name.getAsString(); }
293
294 /// Pretty-print the unqualified name of this declaration. Can be overloaded
295 /// by derived classes to provide a more user-friendly name when appropriate.
296 virtual void printName(raw_ostream &os) const;
297
298 /// Get the actual, stored name of the declaration, which may be a special
299 /// name.
300 ///
301 /// Note that generally in diagnostics, the non-null \p NamedDecl* itself
302 /// should be sent into the diagnostic instead of using the result of
303 /// \p getDeclName().
304 ///
305 /// A \p DeclarationName in a diagnostic will just be streamed to the output,
306 /// which will directly result in a call to \p DeclarationName::print.
307 ///
308 /// A \p NamedDecl* in a diagnostic will also ultimately result in a call to
309 /// \p DeclarationName::print, but with two customisation points along the
310 /// way (\p getNameForDiagnostic and \p printName). These are used to print
311 /// the template arguments if any, and to provide a user-friendly name for
312 /// some entities (such as unnamed variables and anonymous records).
313 DeclarationName getDeclName() const { return Name; }
314
315 /// Set the name of this declaration.
316 void setDeclName(DeclarationName N) { Name = N; }
317
318 /// Returns a human-readable qualified name for this declaration, like
319 /// A::B::i, for i being member of namespace A::B.
320 ///
321 /// If the declaration is not a member of context which can be named (record,
322 /// namespace), it will return the same result as printName().
323 ///
324 /// Creating this name is expensive, so it should be called only when
325 /// performance doesn't matter.
326 void printQualifiedName(raw_ostream &OS) const;
327 void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
328
329 /// Print only the nested name specifier part of a fully-qualified name,
330 /// including the '::' at the end. E.g.
331 /// when `printQualifiedName(D)` prints "A::B::i",
332 /// this function prints "A::B::".
333 void printNestedNameSpecifier(raw_ostream &OS) const;
334 void printNestedNameSpecifier(raw_ostream &OS,
335 const PrintingPolicy &Policy) const;
336
337 // FIXME: Remove string version.
338 std::string getQualifiedNameAsString() const;
339
340 /// Appends a human-readable name for this declaration into the given stream.
341 ///
342 /// This is the method invoked by Sema when displaying a NamedDecl
343 /// in a diagnostic. It does not necessarily produce the same
344 /// result as printName(); for example, class template
345 /// specializations are printed with their template arguments.
346 virtual void getNameForDiagnostic(raw_ostream &OS,
347 const PrintingPolicy &Policy,
348 bool Qualified) const;
349
350 /// Determine whether this declaration, if known to be well-formed within
351 /// its context, will replace the declaration OldD if introduced into scope.
352 ///
353 /// A declaration will replace another declaration if, for example, it is
354 /// a redeclaration of the same variable or function, but not if it is a
355 /// declaration of a different kind (function vs. class) or an overloaded
356 /// function.
357 ///
358 /// \param IsKnownNewer \c true if this declaration is known to be newer
359 /// than \p OldD (for instance, if this declaration is newly-created).
360 bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;
361
362 /// Determine whether this declaration has linkage.
363 bool hasLinkage() const;
364
365 using Decl::isModulePrivate;
366 using Decl::setModulePrivate;
367
368 /// Determine whether this declaration is a C++ class member.
369 bool isCXXClassMember() const {
370 const DeclContext *DC = getDeclContext();
371
372 // C++0x [class.mem]p1:
373 // The enumerators of an unscoped enumeration defined in
374 // the class are members of the class.
375 if (isa<EnumDecl>(DC))
376 DC = DC->getRedeclContext();
377
378 return DC->isRecord();
379 }
380
381 /// Determine whether the given declaration is an instance member of
382 /// a C++ class.
383 bool isCXXInstanceMember() const;
384
385 /// Determine if the declaration obeys the reserved identifier rules of the
386 /// given language.
387 ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;
388
389 /// Determine what kind of linkage this entity has.
390 ///
391 /// This is not the linkage as defined by the standard or the codegen notion
392 /// of linkage. It is just an implementation detail that is used to compute
393 /// those.
394 Linkage getLinkageInternal() const;
395
396 /// Get the linkage from a semantic point of view. Entities in
397 /// anonymous namespaces are external (in c++98).
398 Linkage getFormalLinkage() const {
399 return clang::getFormalLinkage(getLinkageInternal());
400 }
401
402 /// True if this decl has external linkage.
403 bool hasExternalFormalLinkage() const {
404 return isExternalFormalLinkage(getLinkageInternal());
405 }
406
407 bool isExternallyVisible() const {
408 return clang::isExternallyVisible(getLinkageInternal());
409 }
410
411 /// Determine whether this declaration can be redeclared in a
412 /// different translation unit.
413 bool isExternallyDeclarable() const {
414 return isExternallyVisible() && !getOwningModuleForLinkage();
415 }
416
417 /// Determines the visibility of this entity.
418 Visibility getVisibility() const {
419 return getLinkageAndVisibility().getVisibility();
420 }
421
422 /// Determines the linkage and visibility of this entity.
423 LinkageInfo getLinkageAndVisibility() const;
424
425 /// Kinds of explicit visibility.
426 enum ExplicitVisibilityKind {
427 /// Do an LV computation for, ultimately, a type.
428 /// Visibility may be restricted by type visibility settings and
429 /// the visibility of template arguments.
430 VisibilityForType,
431
432 /// Do an LV computation for, ultimately, a non-type declaration.
433 /// Visibility may be restricted by value visibility settings and
434 /// the visibility of template arguments.
435 VisibilityForValue
436 };
437
438 /// If visibility was explicitly specified for this
439 /// declaration, return that visibility.
440 Optional<Visibility>
441 getExplicitVisibility(ExplicitVisibilityKind kind) const;
442
443 /// True if the computed linkage is valid. Used for consistency
444 /// checking. Should always return true.
445 bool isLinkageValid() const;
446
447 /// True if something has required us to compute the linkage
448 /// of this declaration.
449 ///
450 /// Language features which can retroactively change linkage (like a
451 /// typedef name for linkage purposes) may need to consider this,
452 /// but hopefully only in transitory ways during parsing.
453 bool hasLinkageBeenComputed() const {
454 return hasCachedLinkage();
455 }
456
457 /// Looks through UsingDecls and ObjCCompatibleAliasDecls for
458 /// the underlying named decl.
459 NamedDecl *getUnderlyingDecl() {
460 // Fast-path the common case.
461 if (this->getKind() != UsingShadow &&
462 this->getKind() != ConstructorUsingShadow &&
463 this->getKind() != ObjCCompatibleAlias &&
464 this->getKind() != NamespaceAlias)
465 return this;
466
467 return getUnderlyingDeclImpl();
468 }
469 const NamedDecl *getUnderlyingDecl() const {
470 return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
471 }
472
473 NamedDecl *getMostRecentDecl() {
474 return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
475 }
476 const NamedDecl *getMostRecentDecl() const {
477 return const_cast<NamedDecl*>(this)->getMostRecentDecl();
478 }
479
480 ObjCStringFormatFamily getObjCFStringFormattingFamily() const;
481
482 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
483 static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
484};
485
486inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
487 ND.printName(OS);
488 return OS;
489}
490
491/// Represents the declaration of a label. Labels also have a
492/// corresponding LabelStmt, which indicates the position that the label was
493/// defined at. For normal labels, the location of the decl is the same as the
494/// location of the statement. For GNU local labels (__label__), the decl
495/// location is where the __label__ is.
496class LabelDecl : public NamedDecl {
497 LabelStmt *TheStmt;
498 StringRef MSAsmName;
499 bool MSAsmNameResolved = false;
500
501 /// For normal labels, this is the same as the main declaration
502 /// label, i.e., the location of the identifier; for GNU local labels,
503 /// this is the location of the __label__ keyword.
504 SourceLocation LocStart;
505
506 LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
507 LabelStmt *S, SourceLocation StartL)
508 : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
509
510 void anchor() override;
511
512public:
513 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
514 SourceLocation IdentL, IdentifierInfo *II);
515 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
516 SourceLocation IdentL, IdentifierInfo *II,
517 SourceLocation GnuLabelL);
518 static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
519
520 LabelStmt *getStmt() const { return TheStmt; }
521 void setStmt(LabelStmt *T) { TheStmt = T; }
522
523 bool isGnuLocal() const { return LocStart != getLocation(); }
524 void setLocStart(SourceLocation L) { LocStart = L; }
525
526 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
527 return SourceRange(LocStart, getLocation());
528 }
529
530 bool isMSAsmLabel() const { return !MSAsmName.empty(); }
531 bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
532 void setMSAsmLabel(StringRef Name);
533 StringRef getMSAsmLabel() const { return MSAsmName; }
534 void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
535
536 // Implement isa/cast/dyncast/etc.
537 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
538 static bool classofKind(Kind K) { return K == Label; }
539};
540
541/// Represent a C++ namespace.
542class NamespaceDecl : public NamedDecl, public DeclContext,
543 public Redeclarable<NamespaceDecl>
544{
545 /// The starting location of the source range, pointing
546 /// to either the namespace or the inline keyword.
547 SourceLocation LocStart;
548
549 /// The ending location of the source range.
550 SourceLocation RBraceLoc;
551
552 /// A pointer to either the anonymous namespace that lives just inside
553 /// this namespace or to the first namespace in the chain (the latter case
554 /// only when this is not the first in the chain), along with a
555 /// boolean value indicating whether this is an inline namespace.
556 llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;
557
558 NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
559 SourceLocation StartLoc, SourceLocation IdLoc,
560 IdentifierInfo *Id, NamespaceDecl *PrevDecl);
561
562 using redeclarable_base = Redeclarable<NamespaceDecl>;
563
564 NamespaceDecl *getNextRedeclarationImpl() override;
565 NamespaceDecl *getPreviousDeclImpl() override;
566 NamespaceDecl *getMostRecentDeclImpl() override;
567
568public:
569 friend class ASTDeclReader;
570 friend class ASTDeclWriter;
571
572 static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
573 bool Inline, SourceLocation StartLoc,
574 SourceLocation IdLoc, IdentifierInfo *Id,
575 NamespaceDecl *PrevDecl);
576
577 static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
578
579 using redecl_range = redeclarable_base::redecl_range;
580 using redecl_iterator = redeclarable_base::redecl_iterator;
581
582 using redeclarable_base::redecls_begin;
583 using redeclarable_base::redecls_end;
584 using redeclarable_base::redecls;
585 using redeclarable_base::getPreviousDecl;
586 using redeclarable_base::getMostRecentDecl;
587 using redeclarable_base::isFirstDecl;
588
589 /// Returns true if this is an anonymous namespace declaration.
590 ///
591 /// For example:
592 /// \code
593 /// namespace {
594 /// ...
595 /// };
596 /// \endcode
597 /// q.v. C++ [namespace.unnamed]
598 bool isAnonymousNamespace() const {
599 return !getIdentifier();
600 }
601
602 /// Returns true if this is an inline namespace declaration.
603 bool isInline() const {
604 return AnonOrFirstNamespaceAndInline.getInt();
605 }
606
607 /// Set whether this is an inline namespace declaration.
608 void setInline(bool Inline) {
609 AnonOrFirstNamespaceAndInline.setInt(Inline);
610 }
611
612 /// Returns true if the inline qualifier for \c Name is redundant.
613 bool isRedundantInlineQualifierFor(DeclarationName Name) const {
614 if (!isInline())
615 return false;
616 auto X = lookup(Name);
617 auto Y = getParent()->lookup(Name);
618 return std::distance(X.begin(), X.end()) ==
619 std::distance(Y.begin(), Y.end());
620 }
621
622 /// Get the original (first) namespace declaration.
623 NamespaceDecl *getOriginalNamespace();
624
625 /// Get the original (first) namespace declaration.
626 const NamespaceDecl *getOriginalNamespace() const;
627
628 /// Return true if this declaration is an original (first) declaration
629 /// of the namespace. This is false for non-original (subsequent) namespace
630 /// declarations and anonymous namespaces.
631 bool isOriginalNamespace() const;
632
633 /// Retrieve the anonymous namespace nested inside this namespace,
634 /// if any.
635 NamespaceDecl *getAnonymousNamespace() const {
636 return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
637 }
638
639 void setAnonymousNamespace(NamespaceDecl *D) {
640 getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
641 }
642
643 /// Retrieves the canonical declaration of this namespace.
644 NamespaceDecl *getCanonicalDecl() override {
645 return getOriginalNamespace();
646 }
647 const NamespaceDecl *getCanonicalDecl() const {
648 return getOriginalNamespace();
649 }
650
651 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
652 return SourceRange(LocStart, RBraceLoc);
653 }
654
655 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
656 SourceLocation getRBraceLoc() const { return RBraceLoc; }
657 void setLocStart(SourceLocation L) { LocStart = L; }
658 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
659
660 // Implement isa/cast/dyncast/etc.
661 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
662 static bool classofKind(Kind K) { return K == Namespace; }
663 static DeclContext *castToDeclContext(const NamespaceDecl *D) {
664 return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
665 }
666 static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
667 return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
668 }
669};
670
671/// Represent the declaration of a variable (in which case it is
672/// an lvalue) a function (in which case it is a function designator) or
673/// an enum constant.
674class ValueDecl : public NamedDecl {
675 QualType DeclType;
676
677 void anchor() override;
678
679protected:
680 ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
681 DeclarationName N, QualType T)
682 : NamedDecl(DK, DC, L, N), DeclType(T) {}
683
684public:
685 QualType getType() const { return DeclType; }
686 void setType(QualType newType) { DeclType = newType; }
687
688 /// Determine whether this symbol is weakly-imported,
689 /// or declared with the weak or weak-ref attr.
690 bool isWeak() const;
691
692 // Implement isa/cast/dyncast/etc.
693 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
694 static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
695};
696
697/// A struct with extended info about a syntactic
698/// name qualifier, to be used for the case of out-of-line declarations.
699struct QualifierInfo {
700 NestedNameSpecifierLoc QualifierLoc;
701
702 /// The number of "outer" template parameter lists.
703 /// The count includes all of the template parameter lists that were matched
704 /// against the template-ids occurring into the NNS and possibly (in the
705 /// case of an explicit specialization) a final "template <>".
706 unsigned NumTemplParamLists = 0;
707
708 /// A new-allocated array of size NumTemplParamLists,
709 /// containing pointers to the "outer" template parameter lists.
710 /// It includes all of the template parameter lists that were matched
711 /// against the template-ids occurring into the NNS and possibly (in the
712 /// case of an explicit specialization) a final "template <>".
713 TemplateParameterList** TemplParamLists = nullptr;
714
715 QualifierInfo() = default;
716 QualifierInfo(const QualifierInfo &) = delete;
717 QualifierInfo& operator=(const QualifierInfo &) = delete;
718
719 /// Sets info about "outer" template parameter lists.
720 void setTemplateParameterListsInfo(ASTContext &Context,
721 ArrayRef<TemplateParameterList *> TPLists);
722};
723
724/// Represents a ValueDecl that came out of a declarator.
725/// Contains type source information through TypeSourceInfo.
726class DeclaratorDecl : public ValueDecl {
727 // A struct representing a TInfo, a trailing requires-clause and a syntactic
728 // qualifier, to be used for the (uncommon) case of out-of-line declarations
729 // and constrained function decls.
730 struct ExtInfo : public QualifierInfo {
731 TypeSourceInfo *TInfo;
732 Expr *TrailingRequiresClause = nullptr;
733 };
734
735 llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
736
737 /// The start of the source range for this declaration,
738 /// ignoring outer template declarations.
739 SourceLocation InnerLocStart;
740
741 bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
742 ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
743 const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
744
745protected:
746 DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
747 DeclarationName N, QualType T, TypeSourceInfo *TInfo,
748 SourceLocation StartL)
749 : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
750
751public:
752 friend class ASTDeclReader;
753 friend class ASTDeclWriter;
754
755 TypeSourceInfo *getTypeSourceInfo() const {
756 return hasExtInfo()
757 ? getExtInfo()->TInfo
758 : DeclInfo.get<TypeSourceInfo*>();
759 }
760
761 void setTypeSourceInfo(TypeSourceInfo *TI) {
762 if (hasExtInfo())
763 getExtInfo()->TInfo = TI;
764 else
765 DeclInfo = TI;
766 }
767
768 /// Return start of source range ignoring outer template declarations.
769 SourceLocation getInnerLocStart() const { return InnerLocStart; }
770 void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
771
772 /// Return start of source range taking into account any outer template
773 /// declarations.
774 SourceLocation getOuterLocStart() const;
775
776 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
777
778 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
779 return getOuterLocStart();
780 }
781
782 /// Retrieve the nested-name-specifier that qualifies the name of this
783 /// declaration, if it was present in the source.
784 NestedNameSpecifier *getQualifier() const {
785 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
786 : nullptr;
787 }
788
789 /// Retrieve the nested-name-specifier (with source-location
790 /// information) that qualifies the name of this declaration, if it was
791 /// present in the source.
792 NestedNameSpecifierLoc getQualifierLoc() const {
793 return hasExtInfo() ? getExtInfo()->QualifierLoc
794 : NestedNameSpecifierLoc();
795 }
796
797 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
798
799 /// \brief Get the constraint-expression introduced by the trailing
800 /// requires-clause in the function/member declaration, or null if no
801 /// requires-clause was provided.
802 Expr *getTrailingRequiresClause() {
803 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
804 : nullptr;
805 }
806
807 const Expr *getTrailingRequiresClause() const {
808 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
809 : nullptr;
810 }
811
812 void setTrailingRequiresClause(Expr *TrailingRequiresClause);
813
814 unsigned getNumTemplateParameterLists() const {
815 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
816 }
817
818 TemplateParameterList *getTemplateParameterList(unsigned index) const {
819 assert(index < getNumTemplateParameterLists())((void)0);
820 return getExtInfo()->TemplParamLists[index];
821 }
822
823 void setTemplateParameterListsInfo(ASTContext &Context,
824 ArrayRef<TemplateParameterList *> TPLists);
825
826 SourceLocation getTypeSpecStartLoc() const;
827 SourceLocation getTypeSpecEndLoc() const;
828
829 // Implement isa/cast/dyncast/etc.
830 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
831 static bool classofKind(Kind K) {
832 return K >= firstDeclarator && K <= lastDeclarator;
833 }
834};
835
836/// Structure used to store a statement, the constant value to
837/// which it was evaluated (if any), and whether or not the statement
838/// is an integral constant expression (if known).
839struct EvaluatedStmt {
840 /// Whether this statement was already evaluated.
841 bool WasEvaluated : 1;
842
843 /// Whether this statement is being evaluated.
844 bool IsEvaluating : 1;
845
846 /// Whether this variable is known to have constant initialization. This is
847 /// currently only computed in C++, for static / thread storage duration
848 /// variables that might have constant initialization and for variables that
849 /// are usable in constant expressions.
850 bool HasConstantInitialization : 1;
851
852 /// Whether this variable is known to have constant destruction. That is,
853 /// whether running the destructor on the initial value is a side-effect
854 /// (and doesn't inspect any state that might have changed during program
855 /// execution). This is currently only computed if the destructor is
856 /// non-trivial.
857 bool HasConstantDestruction : 1;
858
859 /// In C++98, whether the initializer is an ICE. This affects whether the
860 /// variable is usable in constant expressions.
861 bool HasICEInit : 1;
862 bool CheckedForICEInit : 1;
863
864 Stmt *Value;
865 APValue Evaluated;
866
867 EvaluatedStmt()
868 : WasEvaluated(false), IsEvaluating(false),
869 HasConstantInitialization(false), HasConstantDestruction(false),
870 HasICEInit(false), CheckedForICEInit(false) {}
871};
872
873/// Represents a variable declaration or definition.
874class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
875public:
876 /// Initialization styles.
877 enum InitializationStyle {
878 /// C-style initialization with assignment
879 CInit,
880
881 /// Call-style initialization (C++98)
882 CallInit,
883
884 /// Direct list-initialization (C++11)
885 ListInit
886 };
887
888 /// Kinds of thread-local storage.
889 enum TLSKind {
890 /// Not a TLS variable.
891 TLS_None,
892
893 /// TLS with a known-constant initializer.
894 TLS_Static,
895
896 /// TLS with a dynamic initializer.
897 TLS_Dynamic
898 };
899
900 /// Return the string used to specify the storage class \p SC.
901 ///
902 /// It is illegal to call this function with SC == None.
903 static const char *getStorageClassSpecifierString(StorageClass SC);
904
905protected:
906 // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
907 // have allocated the auxiliary struct of information there.
908 //
909 // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
910 // this as *many* VarDecls are ParmVarDecls that don't have default
911 // arguments. We could save some space by moving this pointer union to be
912 // allocated in trailing space when necessary.
913 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
914
915 /// The initializer for this variable or, for a ParmVarDecl, the
916 /// C++ default argument.
917 mutable InitType Init;
918
919private:
920 friend class ASTDeclReader;
921 friend class ASTNodeImporter;
922 friend class StmtIteratorBase;
923
924 class VarDeclBitfields {
925 friend class ASTDeclReader;
926 friend class VarDecl;
927
928 unsigned SClass : 3;
929 unsigned TSCSpec : 2;
930 unsigned InitStyle : 2;
931
932 /// Whether this variable is an ARC pseudo-__strong variable; see
933 /// isARCPseudoStrong() for details.
934 unsigned ARCPseudoStrong : 1;
935 };
936 enum { NumVarDeclBits = 8 };
937
938protected:
939 enum { NumParameterIndexBits = 8 };
940
941 enum DefaultArgKind {
942 DAK_None,
943 DAK_Unparsed,
944 DAK_Uninstantiated,
945 DAK_Normal
946 };
947
948 enum { NumScopeDepthOrObjCQualsBits = 7 };
949
950 class ParmVarDeclBitfields {
951 friend class ASTDeclReader;
952 friend class ParmVarDecl;
953
954 unsigned : NumVarDeclBits;
955
956 /// Whether this parameter inherits a default argument from a
957 /// prior declaration.
958 unsigned HasInheritedDefaultArg : 1;
959
960 /// Describes the kind of default argument for this parameter. By default
961 /// this is none. If this is normal, then the default argument is stored in
962 /// the \c VarDecl initializer expression unless we were unable to parse
963 /// (even an invalid) expression for the default argument.
964 unsigned DefaultArgKind : 2;
965
966 /// Whether this parameter undergoes K&R argument promotion.
967 unsigned IsKNRPromoted : 1;
968
969 /// Whether this parameter is an ObjC method parameter or not.
970 unsigned IsObjCMethodParam : 1;
971
972 /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
973 /// Otherwise, the number of function parameter scopes enclosing
974 /// the function parameter scope in which this parameter was
975 /// declared.
976 unsigned ScopeDepthOrObjCQuals : NumScopeDepthOrObjCQualsBits;
977
978 /// The number of parameters preceding this parameter in the
979 /// function parameter scope in which it was declared.
980 unsigned ParameterIndex : NumParameterIndexBits;
981 };
982
983 class NonParmVarDeclBitfields {
984 friend class ASTDeclReader;
985 friend class ImplicitParamDecl;
986 friend class VarDecl;
987
988 unsigned : NumVarDeclBits;
989
990 // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
991 /// Whether this variable is a definition which was demoted due to
992 /// module merge.
993 unsigned IsThisDeclarationADemotedDefinition : 1;
994
995 /// Whether this variable is the exception variable in a C++ catch
996 /// or an Objective-C @catch statement.
997 unsigned ExceptionVar : 1;
998
999 /// Whether this local variable could be allocated in the return
1000 /// slot of its function, enabling the named return value optimization
1001 /// (NRVO).
1002 unsigned NRVOVariable : 1;
1003
1004 /// Whether this variable is the for-range-declaration in a C++0x
1005 /// for-range statement.
1006 unsigned CXXForRangeDecl : 1;
1007
1008 /// Whether this variable is the for-in loop declaration in Objective-C.
1009 unsigned ObjCForDecl : 1;
1010
1011 /// Whether this variable is (C++1z) inline.
1012 unsigned IsInline : 1;
1013
1014 /// Whether this variable has (C++1z) inline explicitly specified.
1015 unsigned IsInlineSpecified : 1;
1016
1017 /// Whether this variable is (C++0x) constexpr.
1018 unsigned IsConstexpr : 1;
1019
1020 /// Whether this variable is the implicit variable for a lambda
1021 /// init-capture.
1022 unsigned IsInitCapture : 1;
1023
1024 /// Whether this local extern variable's previous declaration was
1025 /// declared in the same block scope. This controls whether we should merge
1026 /// the type of this declaration with its previous declaration.
1027 unsigned PreviousDeclInSameBlockScope : 1;
1028
1029 /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
1030 /// something else.
1031 unsigned ImplicitParamKind : 3;
1032
1033 unsigned EscapingByref : 1;
1034 };
1035
1036 union {
1037 unsigned AllBits;
1038 VarDeclBitfields VarDeclBits;
1039 ParmVarDeclBitfields ParmVarDeclBits;
1040 NonParmVarDeclBitfields NonParmVarDeclBits;
1041 };
1042
1043 VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1044 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1045 TypeSourceInfo *TInfo, StorageClass SC);
1046
1047 using redeclarable_base = Redeclarable<VarDecl>;
1048
1049 VarDecl *getNextRedeclarationImpl() override {
1050 return getNextRedeclaration();
1051 }
1052
1053 VarDecl *getPreviousDeclImpl() override {
1054 return getPreviousDecl();
1055 }
1056
1057 VarDecl *getMostRecentDeclImpl() override {
1058 return getMostRecentDecl();
1059 }
1060
1061public:
1062 using redecl_range = redeclarable_base::redecl_range;
1063 using redecl_iterator = redeclarable_base::redecl_iterator;
1064
1065 using redeclarable_base::redecls_begin;
1066 using redeclarable_base::redecls_end;
1067 using redeclarable_base::redecls;
1068 using redeclarable_base::getPreviousDecl;
1069 using redeclarable_base::getMostRecentDecl;
1070 using redeclarable_base::isFirstDecl;
1071
1072 static VarDecl *Create(ASTContext &C, DeclContext *DC,
1073 SourceLocation StartLoc, SourceLocation IdLoc,
1074 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1075 StorageClass S);
1076
1077 static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1078
1079 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
1080
1081 /// Returns the storage class as written in the source. For the
1082 /// computed linkage of symbol, see getLinkage.
1083 StorageClass getStorageClass() const {
1084 return (StorageClass) VarDeclBits.SClass;
1085 }
1086 void setStorageClass(StorageClass SC);
1087
1088 void setTSCSpec(ThreadStorageClassSpecifier TSC) {
1089 VarDeclBits.TSCSpec = TSC;
1090 assert(VarDeclBits.TSCSpec == TSC && "truncation")((void)0);
1091 }
1092 ThreadStorageClassSpecifier getTSCSpec() const {
1093 return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
1094 }
1095 TLSKind getTLSKind() const;
1096
1097 /// Returns true if a variable with function scope is a non-static local
1098 /// variable.
1099 bool hasLocalStorage() const {
1100 if (getStorageClass() == SC_None) {
1101 // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
1102 // used to describe variables allocated in global memory and which are
1103 // accessed inside a kernel(s) as read-only variables. As such, variables
1104 // in constant address space cannot have local storage.
1105 if (getType().getAddressSpace() == LangAS::opencl_constant)
1106 return false;
1107 // Second check is for C++11 [dcl.stc]p4.
1108 return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
1109 }
1110
1111 // Global Named Register (GNU extension)
1112 if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
1113 return false;
1114
1115 // Return true for: Auto, Register.
1116 // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
1117
1118 return getStorageClass() >= SC_Auto;
1119 }
1120
1121 /// Returns true if a variable with function scope is a static local
1122 /// variable.
1123 bool isStaticLocal() const {
1124 return (getStorageClass() == SC_Static ||
1125 // C++11 [dcl.stc]p4
1126 (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
1127 && !isFileVarDecl();
1128 }
1129
1130 /// Returns true if a variable has extern or __private_extern__
1131 /// storage.
1132 bool hasExternalStorage() const {
1133 return getStorageClass() == SC_Extern ||
1134 getStorageClass() == SC_PrivateExtern;
1135 }
1136
1137 /// Returns true for all variables that do not have local storage.
1138 ///
1139 /// This includes all global variables as well as static variables declared
1140 /// within a function.
1141 bool hasGlobalStorage() const { return !hasLocalStorage(); }
1142
1143 /// Get the storage duration of this variable, per C++ [basic.stc].
1144 StorageDuration getStorageDuration() const {
1145 return hasLocalStorage() ? SD_Automatic :
1146 getTSCSpec() ? SD_Thread : SD_Static;
1147 }
1148
1149 /// Compute the language linkage.
1150 LanguageLinkage getLanguageLinkage() const;
1151
1152 /// Determines whether this variable is a variable with external, C linkage.
1153 bool isExternC() const;
1154
1155 /// Determines whether this variable's context is, or is nested within,
1156 /// a C++ extern "C" linkage spec.
1157 bool isInExternCContext() const;
1158
1159 /// Determines whether this variable's context is, or is nested within,
1160 /// a C++ extern "C++" linkage spec.
1161 bool isInExternCXXContext() const;
1162
1163 /// Returns true for local variable declarations other than parameters.
1164 /// Note that this includes static variables inside of functions. It also
1165 /// includes variables inside blocks.
1166 ///
1167 /// void foo() { int x; static int y; extern int z; }
1168 bool isLocalVarDecl() const {
1169 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1170 return false;
1171 if (const DeclContext *DC = getLexicalDeclContext())
1172 return DC->getRedeclContext()->isFunctionOrMethod();
1173 return false;
1174 }
1175
1176 /// Similar to isLocalVarDecl but also includes parameters.
1177 bool isLocalVarDeclOrParm() const {
1178 return isLocalVarDecl() || getKind() == Decl::ParmVar;
1179 }
1180
1181 /// Similar to isLocalVarDecl, but excludes variables declared in blocks.
1182 bool isFunctionOrMethodVarDecl() const {
1183 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1184 return false;
1185 const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
1186 return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
1187 }
1188
1189 /// Determines whether this is a static data member.
1190 ///
1191 /// This will only be true in C++, and applies to, e.g., the
1192 /// variable 'x' in:
1193 /// \code
1194 /// struct S {
1195 /// static int x;
1196 /// };
1197 /// \endcode
1198 bool isStaticDataMember() const {
1199 // If it wasn't static, it would be a FieldDecl.
1200 return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
1201 }
1202
1203 VarDecl *getCanonicalDecl() override;
1204 const VarDecl *getCanonicalDecl() const {
1205 return const_cast<VarDecl*>(this)->getCanonicalDecl();
1206 }
1207
1208 enum DefinitionKind {
1209 /// This declaration is only a declaration.
1210 DeclarationOnly,
1211
1212 /// This declaration is a tentative definition.
1213 TentativeDefinition,
1214
1215 /// This declaration is definitely a definition.
1216 Definition
1217 };
1218
1219 /// Check whether this declaration is a definition. If this could be
1220 /// a tentative definition (in C), don't check whether there's an overriding
1221 /// definition.
1222 DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
1223 DefinitionKind isThisDeclarationADefinition() const {
1224 return isThisDeclarationADefinition(getASTContext());
1225 }
1226
1227 /// Check whether this variable is defined in this translation unit.
1228 DefinitionKind hasDefinition(ASTContext &) const;
1229 DefinitionKind hasDefinition() const {
1230 return hasDefinition(getASTContext());
1231 }
1232
1233 /// Get the tentative definition that acts as the real definition in a TU.
1234 /// Returns null if there is a proper definition available.
1235 VarDecl *getActingDefinition();
1236 const VarDecl *getActingDefinition() const {
1237 return const_cast<VarDecl*>(this)->getActingDefinition();
1238 }
1239
1240 /// Get the real (not just tentative) definition for this declaration.
1241 VarDecl *getDefinition(ASTContext &);
1242 const VarDecl *getDefinition(ASTContext &C) const {
1243 return const_cast<VarDecl*>(this)->getDefinition(C);
1244 }
1245 VarDecl *getDefinition() {
1246 return getDefinition(getASTContext());
1247 }
1248 const VarDecl *getDefinition() const {
1249 return const_cast<VarDecl*>(this)->getDefinition();
1250 }
1251
1252 /// Determine whether this is or was instantiated from an out-of-line
1253 /// definition of a static data member.
1254 bool isOutOfLine() const override;
1255
1256 /// Returns true for file scoped variable declaration.
1257 bool isFileVarDecl() const {
1258 Kind K = getKind();
1259 if (K == ParmVar || K == ImplicitParam)
1260 return false;
1261
1262 if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
1263 return true;
1264
1265 if (isStaticDataMember())
1266 return true;
1267
1268 return false;
1269 }
1270
1271 /// Get the initializer for this variable, no matter which
1272 /// declaration it is attached to.
1273 const Expr *getAnyInitializer() const {
1274 const VarDecl *D;
1275 return getAnyInitializer(D);
1276 }
1277
1278 /// Get the initializer for this variable, no matter which
1279 /// declaration it is attached to. Also get that declaration.
1280 const Expr *getAnyInitializer(const VarDecl *&D) const;
1281
1282 bool hasInit() const;
1283 const Expr *getInit() const {
1284 return const_cast<VarDecl *>(this)->getInit();
1285 }
1286 Expr *getInit();
1287
1288 /// Retrieve the address of the initializer expression.
1289 Stmt **getInitAddress();
1290
1291 void setInit(Expr *I);
1292
1293 /// Get the initializing declaration of this variable, if any. This is
1294 /// usually the definition, except that for a static data member it can be
1295 /// the in-class declaration.
1296 VarDecl *getInitializingDeclaration();
1297 const VarDecl *getInitializingDeclaration() const {
1298 return const_cast<VarDecl *>(this)->getInitializingDeclaration();
1299 }
1300
1301 /// Determine whether this variable's value might be usable in a
1302 /// constant expression, according to the relevant language standard.
1303 /// This only checks properties of the declaration, and does not check
1304 /// whether the initializer is in fact a constant expression.
1305 ///
1306 /// This corresponds to C++20 [expr.const]p3's notion of a
1307 /// "potentially-constant" variable.
1308 bool mightBeUsableInConstantExpressions(const ASTContext &C) const;
1309
1310 /// Determine whether this variable's value can be used in a
1311 /// constant expression, according to the relevant language standard,
1312 /// including checking whether it was initialized by a constant expression.
1313 bool isUsableInConstantExpressions(const ASTContext &C) const;
1314
1315 EvaluatedStmt *ensureEvaluatedStmt() const;
1316 EvaluatedStmt *getEvaluatedStmt() const;
1317
1318 /// Attempt to evaluate the value of the initializer attached to this
1319 /// declaration, and produce notes explaining why it cannot be evaluated.
1320 /// Returns a pointer to the value if evaluation succeeded, 0 otherwise.
1321 APValue *evaluateValue() const;
1322
1323private:
1324 APValue *evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
1325 bool IsConstantInitialization) const;
1326
1327public:
1328 /// Return the already-evaluated value of this variable's
1329 /// initializer, or NULL if the value is not yet known. Returns pointer
1330 /// to untyped APValue if the value could not be evaluated.
1331 APValue *getEvaluatedValue() const;
1332
1333 /// Evaluate the destruction of this variable to determine if it constitutes
1334 /// constant destruction.
1335 ///
1336 /// \pre hasConstantInitialization()
1337 /// \return \c true if this variable has constant destruction, \c false if
1338 /// not.
1339 bool evaluateDestruction(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1340
1341 /// Determine whether this variable has constant initialization.
1342 ///
1343 /// This is only set in two cases: when the language semantics require
1344 /// constant initialization (globals in C and some globals in C++), and when
1345 /// the variable is usable in constant expressions (constexpr, const int, and
1346 /// reference variables in C++).
1347 bool hasConstantInitialization() const;
1348
1349 /// Determine whether the initializer of this variable is an integer constant
1350 /// expression. For use in C++98, where this affects whether the variable is
1351 /// usable in constant expressions.
1352 bool hasICEInitializer(const ASTContext &Context) const;
1353
1354 /// Evaluate the initializer of this variable to determine whether it's a
1355 /// constant initializer. Should only be called once, after completing the
1356 /// definition of the variable.
1357 bool checkForConstantInitialization(
1358 SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1359
1360 void setInitStyle(InitializationStyle Style) {
1361 VarDeclBits.InitStyle = Style;
1362 }
1363
1364 /// The style of initialization for this declaration.
1365 ///
1366 /// C-style initialization is "int x = 1;". Call-style initialization is
1367 /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1368 /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1369 /// expression for class types. List-style initialization is C++11 syntax,
1370 /// e.g. "int x{1};". Clients can distinguish between different forms of
1371 /// initialization by checking this value. In particular, "int x = {1};" is
1372 /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1373 /// Init expression in all three cases is an InitListExpr.
1374 InitializationStyle getInitStyle() const {
1375 return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1376 }
1377
1378 /// Whether the initializer is a direct-initializer (list or call).
1379 bool isDirectInit() const {
1380 return getInitStyle() != CInit;
1381 }
1382
1383 /// If this definition should pretend to be a declaration.
1384 bool isThisDeclarationADemotedDefinition() const {
1385 return isa<ParmVarDecl>(this) ? false :
1386 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
1387 }
1388
1389 /// This is a definition which should be demoted to a declaration.
1390 ///
1391 /// In some cases (mostly module merging) we can end up with two visible
1392 /// definitions one of which needs to be demoted to a declaration to keep
1393 /// the AST invariants.
1394 void demoteThisDefinitionToDeclaration() {
1395 assert(isThisDeclarationADefinition() && "Not a definition!")((void)0);
1396 assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!")((void)0);
1397 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
1398 }
1399
1400 /// Determine whether this variable is the exception variable in a
1401 /// C++ catch statememt or an Objective-C \@catch statement.
1402 bool isExceptionVariable() const {
1403 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
1404 }
1405 void setExceptionVariable(bool EV) {
1406 assert(!isa<ParmVarDecl>(this))((void)0);
1407 NonParmVarDeclBits.ExceptionVar = EV;
1408 }
1409
1410 /// Determine whether this local variable can be used with the named
1411 /// return value optimization (NRVO).
1412 ///
1413 /// The named return value optimization (NRVO) works by marking certain
1414 /// non-volatile local variables of class type as NRVO objects. These
1415 /// locals can be allocated within the return slot of their containing
1416 /// function, in which case there is no need to copy the object to the
1417 /// return slot when returning from the function. Within the function body,
1418 /// each return that returns the NRVO object will have this variable as its
1419 /// NRVO candidate.
1420 bool isNRVOVariable() const {
1421 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
1422 }
1423 void setNRVOVariable(bool NRVO) {
1424 assert(!isa<ParmVarDecl>(this))((void)0);
1425 NonParmVarDeclBits.NRVOVariable = NRVO;
1426 }
1427
1428 /// Determine whether this variable is the for-range-declaration in
1429 /// a C++0x for-range statement.
1430 bool isCXXForRangeDecl() const {
1431 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
1432 }
1433 void setCXXForRangeDecl(bool FRD) {
1434 assert(!isa<ParmVarDecl>(this))((void)0);
1435 NonParmVarDeclBits.CXXForRangeDecl = FRD;
1436 }
1437
1438 /// Determine whether this variable is a for-loop declaration for a
1439 /// for-in statement in Objective-C.
1440 bool isObjCForDecl() const {
1441 return NonParmVarDeclBits.ObjCForDecl;
1442 }
1443
1444 void setObjCForDecl(bool FRD) {
1445 NonParmVarDeclBits.ObjCForDecl = FRD;
1446 }
1447
1448 /// Determine whether this variable is an ARC pseudo-__strong variable. A
1449 /// pseudo-__strong variable has a __strong-qualified type but does not
1450 /// actually retain the object written into it. Generally such variables are
1451 /// also 'const' for safety. There are 3 cases where this will be set, 1) if
1452 /// the variable is annotated with the objc_externally_retained attribute, 2)
1453 /// if its 'self' in a non-init method, or 3) if its the variable in an for-in
1454 /// loop.
1455 bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; }
1456 void setARCPseudoStrong(bool PS) { VarDeclBits.ARCPseudoStrong = PS; }
1457
1458 /// Whether this variable is (C++1z) inline.
1459 bool isInline() const {
1460 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
1461 }
1462 bool isInlineSpecified() const {
1463 return isa<ParmVarDecl>(this) ? false
1464 : NonParmVarDeclBits.IsInlineSpecified;
1465 }
1466 void setInlineSpecified() {
1467 assert(!isa<ParmVarDecl>(this))((void)0);
1468 NonParmVarDeclBits.IsInline = true;
1469 NonParmVarDeclBits.IsInlineSpecified = true;
1470 }
1471 void setImplicitlyInline() {
1472 assert(!isa<ParmVarDecl>(this))((void)0);
1473 NonParmVarDeclBits.IsInline = true;
1474 }
1475
1476 /// Whether this variable is (C++11) constexpr.
1477 bool isConstexpr() const {
1478 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
1479 }
1480 void setConstexpr(bool IC) {
1481 assert(!isa<ParmVarDecl>(this))((void)0);
1482 NonParmVarDeclBits.IsConstexpr = IC;
1483 }
1484
1485 /// Whether this variable is the implicit variable for a lambda init-capture.
1486 bool isInitCapture() const {
1487 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
1488 }
1489 void setInitCapture(bool IC) {
1490 assert(!isa<ParmVarDecl>(this))((void)0);
1491 NonParmVarDeclBits.IsInitCapture = IC;
1492 }
1493
1494 /// Determine whether this variable is actually a function parameter pack or
1495 /// init-capture pack.
1496 bool isParameterPack() const;
1497
1498 /// Whether this local extern variable declaration's previous declaration
1499 /// was declared in the same block scope. Only correct in C++.
1500 bool isPreviousDeclInSameBlockScope() const {
1501 return isa<ParmVarDecl>(this)
1502 ? false
1503 : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
1504 }
1505 void setPreviousDeclInSameBlockScope(bool Same) {
1506 assert(!isa<ParmVarDecl>(this))((void)0);
1507 NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
1508 }
1509
1510 /// Indicates the capture is a __block variable that is captured by a block
1511 /// that can potentially escape (a block for which BlockDecl::doesNotEscape
1512 /// returns false).
1513 bool isEscapingByref() const;
1514
1515 /// Indicates the capture is a __block variable that is never captured by an
1516 /// escaping block.
1517 bool isNonEscapingByref() const;
1518
1519 void setEscapingByref() {
1520 NonParmVarDeclBits.EscapingByref = true;
1521 }
1522
1523 /// Determines if this variable's alignment is dependent.
1524 bool hasDependentAlignment() const;
1525
1526 /// Retrieve the variable declaration from which this variable could
1527 /// be instantiated, if it is an instantiation (rather than a non-template).
1528 VarDecl *getTemplateInstantiationPattern() const;
1529
1530 /// If this variable is an instantiated static data member of a
1531 /// class template specialization, returns the templated static data member
1532 /// from which it was instantiated.
1533 VarDecl *getInstantiatedFromStaticDataMember() const;
1534
1535 /// If this variable is an instantiation of a variable template or a
1536 /// static data member of a class template, determine what kind of
1537 /// template specialization or instantiation this is.
1538 TemplateSpecializationKind getTemplateSpecializationKind() const;
1539
1540 /// Get the template specialization kind of this variable for the purposes of
1541 /// template instantiation. This differs from getTemplateSpecializationKind()
1542 /// for an instantiation of a class-scope explicit specialization.
1543 TemplateSpecializationKind
1544 getTemplateSpecializationKindForInstantiation() const;
1545
1546 /// If this variable is an instantiation of a variable template or a
1547 /// static data member of a class template, determine its point of
1548 /// instantiation.
1549 SourceLocation getPointOfInstantiation() const;
1550
1551 /// If this variable is an instantiation of a static data member of a
1552 /// class template specialization, retrieves the member specialization
1553 /// information.
1554 MemberSpecializationInfo *getMemberSpecializationInfo() const;
1555
1556 /// For a static data member that was instantiated from a static
1557 /// data member of a class template, set the template specialiation kind.
1558 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
1559 SourceLocation PointOfInstantiation = SourceLocation());
1560
1561 /// Specify that this variable is an instantiation of the
1562 /// static data member VD.
1563 void setInstantiationOfStaticDataMember(VarDecl *VD,
1564 TemplateSpecializationKind TSK);
1565
1566 /// Retrieves the variable template that is described by this
1567 /// variable declaration.
1568 ///
1569 /// Every variable template is represented as a VarTemplateDecl and a
1570 /// VarDecl. The former contains template properties (such as
1571 /// the template parameter lists) while the latter contains the
1572 /// actual description of the template's
1573 /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1574 /// VarDecl that from a VarTemplateDecl, while
1575 /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1576 /// a VarDecl.
1577 VarTemplateDecl *getDescribedVarTemplate() const;
1578
1579 void setDescribedVarTemplate(VarTemplateDecl *Template);
1580
1581 // Is this variable known to have a definition somewhere in the complete
1582 // program? This may be true even if the declaration has internal linkage and
1583 // has no definition within this source file.
1584 bool isKnownToBeDefined() const;
1585
1586 /// Is destruction of this variable entirely suppressed? If so, the variable
1587 /// need not have a usable destructor at all.
1588 bool isNoDestroy(const ASTContext &) const;
1589
1590 /// Would the destruction of this variable have any effect, and if so, what
1591 /// kind?
1592 QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const;
1593
1594 // Implement isa/cast/dyncast/etc.
1595 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1596 static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1597};
1598
1599class ImplicitParamDecl : public VarDecl {
1600 void anchor() override;
1601
1602public:
1603 /// Defines the kind of the implicit parameter: is this an implicit parameter
1604 /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
1605 /// context or something else.
1606 enum ImplicitParamKind : unsigned {
1607 /// Parameter for Objective-C 'self' argument
1608 ObjCSelf,
1609
1610 /// Parameter for Objective-C '_cmd' argument
1611 ObjCCmd,
1612
1613 /// Parameter for C++ 'this' argument
1614 CXXThis,
1615
1616 /// Parameter for C++ virtual table pointers
1617 CXXVTT,
1618
1619 /// Parameter for captured context
1620 CapturedContext,
1621
1622 /// Other implicit parameter
1623 Other,
1624 };
1625
1626 /// Create implicit parameter.
1627 static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
1628 SourceLocation IdLoc, IdentifierInfo *Id,
1629 QualType T, ImplicitParamKind ParamKind);
1630 static ImplicitParamDecl *Create(ASTContext &C, QualType T,
1631 ImplicitParamKind ParamKind);
1632
1633 static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1634
1635 ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
1636 IdentifierInfo *Id, QualType Type,
1637 ImplicitParamKind ParamKind)
1638 : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1639 /*TInfo=*/nullptr, SC_None) {
1640 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1641 setImplicit();
1642 }
1643
1644 ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
1645 : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
1646 SourceLocation(), /*Id=*/nullptr, Type,
1647 /*TInfo=*/nullptr, SC_None) {
1648 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1649 setImplicit();
1650 }
1651
1652 /// Returns the implicit parameter kind.
1653 ImplicitParamKind getParameterKind() const {
1654 return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
1655 }
1656
1657 // Implement isa/cast/dyncast/etc.
1658 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1659 static bool classofKind(Kind K) { return K == ImplicitParam; }
1660};
1661
1662/// Represents a parameter to a function.
1663class ParmVarDecl : public VarDecl {
1664public:
1665 enum { MaxFunctionScopeDepth = 255 };
1666 enum { MaxFunctionScopeIndex = 255 };
1667
1668protected:
1669 ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1670 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1671 TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1672 : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1673 assert(ParmVarDeclBits.HasInheritedDefaultArg == false)((void)0);
1674 assert(ParmVarDeclBits.DefaultArgKind == DAK_None)((void)0);
1675 assert(ParmVarDeclBits.IsKNRPromoted == false)((void)0);
1676 assert(ParmVarDeclBits.IsObjCMethodParam == false)((void)0);
1677 setDefaultArg(DefArg);
1678 }
1679
1680public:
1681 static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1682 SourceLocation StartLoc,
1683 SourceLocation IdLoc, IdentifierInfo *Id,
1684 QualType T, TypeSourceInfo *TInfo,
1685 StorageClass S, Expr *DefArg);
1686
1687 static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1688
1689 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
1690
1691 void setObjCMethodScopeInfo(unsigned parameterIndex) {
1692 ParmVarDeclBits.IsObjCMethodParam = true;
1693 setParameterIndex(parameterIndex);
1694 }
1695
1696 void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1697 assert(!ParmVarDeclBits.IsObjCMethodParam)((void)0);
1698
1699 ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1700 assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth((void)0)
1701 && "truncation!")((void)0);
1702
1703 setParameterIndex(parameterIndex);
1704 }
1705
1706 bool isObjCMethodParameter() const {
1707 return ParmVarDeclBits.IsObjCMethodParam;
1708 }
1709
1710 /// Determines whether this parameter is destroyed in the callee function.
1711 bool isDestroyedInCallee() const;
1712
1713 unsigned getFunctionScopeDepth() const {
1714 if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1715 return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1716 }
1717
1718 static constexpr unsigned getMaxFunctionScopeDepth() {
1719 return (1u << NumScopeDepthOrObjCQualsBits) - 1;
1720 }
1721
1722 /// Returns the index of this parameter in its prototype or method scope.
1723 unsigned getFunctionScopeIndex() const {
1724 return getParameterIndex();
1725 }
1726
1727 ObjCDeclQualifier getObjCDeclQualifier() const {
1728 if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1729 return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1730 }
1731 void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
1732 assert(ParmVarDeclBits.IsObjCMethodParam)((void)0);
1733 ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1734 }
1735
1736 /// True if the value passed to this parameter must undergo
1737 /// K&R-style default argument promotion:
1738 ///
1739 /// C99 6.5.2.2.
1740 /// If the expression that denotes the called function has a type
1741 /// that does not include a prototype, the integer promotions are
1742 /// performed on each argument, and arguments that have type float
1743 /// are promoted to double.
1744 bool isKNRPromoted() const {
1745 return ParmVarDeclBits.IsKNRPromoted;
1746 }
1747 void setKNRPromoted(bool promoted) {
1748 ParmVarDeclBits.IsKNRPromoted = promoted;
1749 }
1750
1751 Expr *getDefaultArg();
1752 const Expr *getDefaultArg() const {
1753 return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1754 }
1755
1756 void setDefaultArg(Expr *defarg);
1757
1758 /// Retrieve the source range that covers the entire default
1759 /// argument.
1760 SourceRange getDefaultArgRange() const;
1761 void setUninstantiatedDefaultArg(Expr *arg);
1762 Expr *getUninstantiatedDefaultArg();
1763 const Expr *getUninstantiatedDefaultArg() const {
1764 return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
1765 }
1766
1767 /// Determines whether this parameter has a default argument,
1768 /// either parsed or not.
1769 bool hasDefaultArg() const;
1770
1771 /// Determines whether this parameter has a default argument that has not
1772 /// yet been parsed. This will occur during the processing of a C++ class
1773 /// whose member functions have default arguments, e.g.,
1774 /// @code
1775 /// class X {
1776 /// public:
1777 /// void f(int x = 17); // x has an unparsed default argument now
1778 /// }; // x has a regular default argument now
1779 /// @endcode
1780 bool hasUnparsedDefaultArg() const {
1781 return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
1782 }
1783
1784 bool hasUninstantiatedDefaultArg() const {
1785 return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
1786 }
1787
1788 /// Specify that this parameter has an unparsed default argument.
1789 /// The argument will be replaced with a real default argument via
1790 /// setDefaultArg when the class definition enclosing the function
1791 /// declaration that owns this default argument is completed.
1792 void setUnparsedDefaultArg() {
1793 ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
1794 }
1795
1796 bool hasInheritedDefaultArg() const {
1797 return ParmVarDeclBits.HasInheritedDefaultArg;
1798 }
1799
1800 void setHasInheritedDefaultArg(bool I = true) {
1801 ParmVarDeclBits.HasInheritedDefaultArg = I;
1802 }
1803
1804 QualType getOriginalType() const;
1805
1806 /// Sets the function declaration that owns this
1807 /// ParmVarDecl. Since ParmVarDecls are often created before the
1808 /// FunctionDecls that own them, this routine is required to update
1809 /// the DeclContext appropriately.
1810 void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }
1811
1812 // Implement isa/cast/dyncast/etc.
1813 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1814 static bool classofKind(Kind K) { return K == ParmVar; }
1815
1816private:
1817 enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1818
1819 void setParameterIndex(unsigned parameterIndex) {
1820 if (parameterIndex >= ParameterIndexSentinel) {
1821 setParameterIndexLarge(parameterIndex);
1822 return;
1823 }
1824
1825 ParmVarDeclBits.ParameterIndex = parameterIndex;
1826 assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!")((void)0);
1827 }
1828 unsigned getParameterIndex() const {
1829 unsigned d = ParmVarDeclBits.ParameterIndex;
1830 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1831 }
1832
1833 void setParameterIndexLarge(unsigned parameterIndex);
1834 unsigned getParameterIndexLarge() const;
1835};
1836
1837enum class MultiVersionKind {
1838 None,
1839 Target,
1840 CPUSpecific,
1841 CPUDispatch
1842};
1843
1844/// Represents a function declaration or definition.
1845///
1846/// Since a given function can be declared several times in a program,
1847/// there may be several FunctionDecls that correspond to that
1848/// function. Only one of those FunctionDecls will be found when
1849/// traversing the list of declarations in the context of the
1850/// FunctionDecl (e.g., the translation unit); this FunctionDecl
1851/// contains all of the information known about the function. Other,
1852/// previous declarations of the function are available via the
1853/// getPreviousDecl() chain.
1854class FunctionDecl : public DeclaratorDecl,
1855 public DeclContext,
1856 public Redeclarable<FunctionDecl> {
1857 // This class stores some data in DeclContext::FunctionDeclBits
1858 // to save some space. Use the provided accessors to access it.
1859public:
1860 /// The kind of templated function a FunctionDecl can be.
1861 enum TemplatedKind {
1862 // Not templated.
1863 TK_NonTemplate,
1864 // The pattern in a function template declaration.
1865 TK_FunctionTemplate,
1866 // A non-template function that is an instantiation or explicit
1867 // specialization of a member of a templated class.
1868 TK_MemberSpecialization,
1869 // An instantiation or explicit specialization of a function template.
1870 // Note: this might have been instantiated from a templated class if it
1871 // is a class-scope explicit specialization.
1872 TK_FunctionTemplateSpecialization,
1873 // A function template specialization that hasn't yet been resolved to a
1874 // particular specialized function template.
1875 TK_DependentFunctionTemplateSpecialization
1876 };
1877
1878 /// Stashed information about a defaulted function definition whose body has
1879 /// not yet been lazily generated.
1880 class DefaultedFunctionInfo final
1881 : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
1882 friend TrailingObjects;
1883 unsigned NumLookups;
1884
1885 public:
1886 static DefaultedFunctionInfo *Create(ASTContext &Context,
1887 ArrayRef<DeclAccessPair> Lookups);
1888 /// Get the unqualified lookup results that should be used in this
1889 /// defaulted function definition.
1890 ArrayRef<DeclAccessPair> getUnqualifiedLookups() const {
1891 return {getTrailingObjects<DeclAccessPair>(), NumLookups};
1892 }
1893 };
1894
1895private:
1896 /// A new[]'d array of pointers to VarDecls for the formal
1897 /// parameters of this function. This is null if a prototype or if there are
1898 /// no formals.
1899 ParmVarDecl **ParamInfo = nullptr;
1900
1901 /// The active member of this union is determined by
1902 /// FunctionDeclBits.HasDefaultedFunctionInfo.
1903 union {
1904 /// The body of the function.
1905 LazyDeclStmtPtr Body;
1906 /// Information about a future defaulted function definition.
1907 DefaultedFunctionInfo *DefaultedInfo;
1908 };
1909
1910 unsigned ODRHash;
1911
1912 /// End part of this FunctionDecl's source range.
1913 ///
1914 /// We could compute the full range in getSourceRange(). However, when we're
1915 /// dealing with a function definition deserialized from a PCH/AST file,
1916 /// we can only compute the full range once the function body has been
1917 /// de-serialized, so it's far better to have the (sometimes-redundant)
1918 /// EndRangeLoc.
1919 SourceLocation EndRangeLoc;
1920
1921 /// The template or declaration that this declaration
1922 /// describes or was instantiated from, respectively.
1923 ///
1924 /// For non-templates, this value will be NULL. For function
1925 /// declarations that describe a function template, this will be a
1926 /// pointer to a FunctionTemplateDecl. For member functions
1927 /// of class template specializations, this will be a MemberSpecializationInfo
1928 /// pointer containing information about the specialization.
1929 /// For function template specializations, this will be a
1930 /// FunctionTemplateSpecializationInfo, which contains information about
1931 /// the template being specialized and the template arguments involved in
1932 /// that specialization.
1933 llvm::PointerUnion<FunctionTemplateDecl *,
1934 MemberSpecializationInfo *,
1935 FunctionTemplateSpecializationInfo *,
1936 DependentFunctionTemplateSpecializationInfo *>
1937 TemplateOrSpecialization;
1938
1939 /// Provides source/type location info for the declaration name embedded in
1940 /// the DeclaratorDecl base class.
1941 DeclarationNameLoc DNLoc;
1942
1943 /// Specify that this function declaration is actually a function
1944 /// template specialization.
1945 ///
1946 /// \param C the ASTContext.
1947 ///
1948 /// \param Template the function template that this function template
1949 /// specialization specializes.
1950 ///
1951 /// \param TemplateArgs the template arguments that produced this
1952 /// function template specialization from the template.
1953 ///
1954 /// \param InsertPos If non-NULL, the position in the function template
1955 /// specialization set where the function template specialization data will
1956 /// be inserted.
1957 ///
1958 /// \param TSK the kind of template specialization this is.
1959 ///
1960 /// \param TemplateArgsAsWritten location info of template arguments.
1961 ///
1962 /// \param PointOfInstantiation point at which the function template
1963 /// specialization was first instantiated.
1964 void setFunctionTemplateSpecialization(ASTContext &C,
1965 FunctionTemplateDecl *Template,
1966 const TemplateArgumentList *TemplateArgs,
1967 void *InsertPos,
1968 TemplateSpecializationKind TSK,
1969 const TemplateArgumentListInfo *TemplateArgsAsWritten,
1970 SourceLocation PointOfInstantiation);
1971
1972 /// Specify that this record is an instantiation of the
1973 /// member function FD.
1974 void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
1975 TemplateSpecializationKind TSK);
1976
1977 void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
1978
1979 // This is unfortunately needed because ASTDeclWriter::VisitFunctionDecl
1980 // need to access this bit but we want to avoid making ASTDeclWriter
1981 // a friend of FunctionDeclBitfields just for this.
1982 bool isDeletedBit() const { return FunctionDeclBits.IsDeleted; }
1983
1984 /// Whether an ODRHash has been stored.
1985 bool hasODRHash() const { return FunctionDeclBits.HasODRHash; }
1986
1987 /// State that an ODRHash has been stored.
1988 void setHasODRHash(bool B = true) { FunctionDeclBits.HasODRHash = B; }
1989
1990protected:
1991 FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1992 const DeclarationNameInfo &NameInfo, QualType T,
1993 TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
1994 ConstexprSpecKind ConstexprKind,
1995 Expr *TrailingRequiresClause = nullptr);
1996
1997 using redeclarable_base = Redeclarable<FunctionDecl>;
1998
1999 FunctionDecl *getNextRedeclarationImpl() override {
2000 return getNextRedeclaration();
2001 }
2002
2003 FunctionDecl *getPreviousDeclImpl() override {
2004 return getPreviousDecl();
2005 }
2006
2007 FunctionDecl *getMostRecentDeclImpl() override {
2008 return getMostRecentDecl();
2009 }
2010
2011public:
2012 friend class ASTDeclReader;
2013 friend class ASTDeclWriter;
2014
2015 using redecl_range = redeclarable_base::redecl_range;
2016 using redecl_iterator = redeclarable_base::redecl_iterator;
2017
2018 using redeclarable_base::redecls_begin;
2019 using redeclarable_base::redecls_end;
2020 using redeclarable_base::redecls;
2021 using redeclarable_base::getPreviousDecl;
2022 using redeclarable_base::getMostRecentDecl;
2023 using redeclarable_base::isFirstDecl;
2024
2025 static FunctionDecl *
2026 Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2027 SourceLocation NLoc, DeclarationName N, QualType T,
2028 TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified = false,
2029 bool hasWrittenPrototype = true,
2030 ConstexprSpecKind ConstexprKind = ConstexprSpecKind::Unspecified,
2031 Expr *TrailingRequiresClause = nullptr) {
2032 DeclarationNameInfo NameInfo(N, NLoc);
2033 return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
2034 isInlineSpecified, hasWrittenPrototype,
2035 ConstexprKind, TrailingRequiresClause);
2036 }
2037
2038 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
2039 SourceLocation StartLoc,
2040 const DeclarationNameInfo &NameInfo, QualType T,
2041 TypeSourceInfo *TInfo, StorageClass SC,
2042 bool isInlineSpecified, bool hasWrittenPrototype,
2043 ConstexprSpecKind ConstexprKind,
2044 Expr *TrailingRequiresClause);
2045
2046 static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2047
2048 DeclarationNameInfo getNameInfo() const {
2049 return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
2050 }
2051
2052 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2053 bool Qualified) const override;
2054
2055 void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
2056
2057 /// Returns the location of the ellipsis of a variadic function.
2058 SourceLocation getEllipsisLoc() const {
2059 const auto *FPT = getType()->getAs<FunctionProtoType>();
2060 if (FPT && FPT->isVariadic())
2061 return FPT->getEllipsisLoc();
2062 return SourceLocation();
2063 }
2064
2065 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
2066
2067 // Function definitions.
2068 //
2069 // A function declaration may be:
2070 // - a non defining declaration,
2071 // - a definition. A function may be defined because:
2072 // - it has a body, or will have it in the case of late parsing.
2073 // - it has an uninstantiated body. The body does not exist because the
2074 // function is not used yet, but the declaration is considered a
2075 // definition and does not allow other definition of this function.
2076 // - it does not have a user specified body, but it does not allow
2077 // redefinition, because it is deleted/defaulted or is defined through
2078 // some other mechanism (alias, ifunc).
2079
2080 /// Returns true if the function has a body.
2081 ///
2082 /// The function body might be in any of the (re-)declarations of this
2083 /// function. The variant that accepts a FunctionDecl pointer will set that
2084 /// function declaration to the actual declaration containing the body (if
2085 /// there is one).
2086 bool hasBody(const FunctionDecl *&Definition) const;
2087
2088 bool hasBody() const override {
2089 const FunctionDecl* Definition;
2090 return hasBody(Definition);
2091 }
2092
2093 /// Returns whether the function has a trivial body that does not require any
2094 /// specific codegen.
2095 bool hasTrivialBody() const;
2096
2097 /// Returns true if the function has a definition that does not need to be
2098 /// instantiated.
2099 ///
2100 /// The variant that accepts a FunctionDecl pointer will set that function
2101 /// declaration to the declaration that is a definition (if there is one).
2102 ///
2103 /// \param CheckForPendingFriendDefinition If \c true, also check for friend
2104 /// declarations that were instantiataed from function definitions.
2105 /// Such a declaration behaves as if it is a definition for the
2106 /// purpose of redefinition checking, but isn't actually a "real"
2107 /// definition until its body is instantiated.
2108 bool isDefined(const FunctionDecl *&Definition,
2109 bool CheckForPendingFriendDefinition = false) const;
2110
2111 bool isDefined() const {
2112 const FunctionDecl* Definition;
2113 return isDefined(Definition);
2114 }
2115
2116 /// Get the definition for this declaration.
2117 FunctionDecl *getDefinition() {
2118 const FunctionDecl *Definition;
2119 if (isDefined(Definition))
2120 return const_cast<FunctionDecl *>(Definition);
2121 return nullptr;
2122 }
2123 const FunctionDecl *getDefinition() const {
2124 return const_cast<FunctionDecl *>(this)->getDefinition();
2125 }
2126
2127 /// Retrieve the body (definition) of the function. The function body might be
2128 /// in any of the (re-)declarations of this function. The variant that accepts
2129 /// a FunctionDecl pointer will set that function declaration to the actual
2130 /// declaration containing the body (if there is one).
2131 /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
2132 /// unnecessary AST de-serialization of the body.
2133 Stmt *getBody(const FunctionDecl *&Definition) const;
2134
2135 Stmt *getBody() const override {
2136 const FunctionDecl* Definition;
2137 return getBody(Definition);
2138 }
2139
2140 /// Returns whether this specific declaration of the function is also a
2141 /// definition that does not contain uninstantiated body.
2142 ///
2143 /// This does not determine whether the function has been defined (e.g., in a
2144 /// previous definition); for that information, use isDefined.
2145 ///
2146 /// Note: the function declaration does not become a definition until the
2147 /// parser reaches the definition, if called before, this function will return
2148 /// `false`.
2149 bool isThisDeclarationADefinition() const {
2150 return isDeletedAsWritten() || isDefaulted() ||
2151 doesThisDeclarationHaveABody() || hasSkippedBody() ||
2152 willHaveBody() || hasDefiningAttr();
2153 }
2154
2155 /// Determine whether this specific declaration of the function is a friend
2156 /// declaration that was instantiated from a function definition. Such
2157 /// declarations behave like definitions in some contexts.
2158 bool isThisDeclarationInstantiatedFromAFriendDefinition() const;
2159
2160 /// Returns whether this specific declaration of the function has a body.
2161 bool doesThisDeclarationHaveABody() const {
2162 return (!FunctionDeclBits.HasDefaultedFunctionInfo && Body) ||
2163 isLateTemplateParsed();
2164 }
2165
2166 void setBody(Stmt *B);
2167 void setLazyBody(uint64_t Offset) {
2168 FunctionDeclBits.HasDefaultedFunctionInfo = false;
2169 Body = LazyDeclStmtPtr(Offset);
2170 }
2171
2172 void setDefaultedFunctionInfo(DefaultedFunctionInfo *Info);
2173 DefaultedFunctionInfo *getDefaultedFunctionInfo() const;
2174
2175 /// Whether this function is variadic.
2176 bool isVariadic() const;
2177
2178 /// Whether this function is marked as virtual explicitly.
2179 bool isVirtualAsWritten() const {
2180 return FunctionDeclBits.IsVirtualAsWritten;
2181 }
2182
2183 /// State that this function is marked as virtual explicitly.
2184 void setVirtualAsWritten(bool V) { FunctionDeclBits.IsVirtualAsWritten = V; }
2185
2186 /// Whether this virtual function is pure, i.e. makes the containing class
2187 /// abstract.
2188 bool isPure() const { return FunctionDeclBits.IsPure; }
2189 void setPure(bool P = true);
2190
2191 /// Whether this templated function will be late parsed.
2192 bool isLateTemplateParsed() const {
2193 return FunctionDeclBits.IsLateTemplateParsed;
2194 }
2195
2196 /// State that this templated function will be late parsed.
2197 void setLateTemplateParsed(bool ILT = true) {
2198 FunctionDeclBits.IsLateTemplateParsed = ILT;
2199 }
2200
2201 /// Whether this function is "trivial" in some specialized C++ senses.
2202 /// Can only be true for default constructors, copy constructors,
2203 /// copy assignment operators, and destructors. Not meaningful until
2204 /// the class has been fully built by Sema.
2205 bool isTrivial() const { return FunctionDeclBits.IsTrivial; }
2206 void setTrivial(bool IT) { FunctionDeclBits.IsTrivial = IT; }
2207
2208 bool isTrivialForCall() const { return FunctionDeclBits.IsTrivialForCall; }
2209 void setTrivialForCall(bool IT) { FunctionDeclBits.IsTrivialForCall = IT; }
2210
2211 /// Whether this function is defaulted. Valid for e.g.
2212 /// special member functions, defaulted comparisions (not methods!).
2213 bool isDefaulted() const { return FunctionDeclBits.IsDefaulted; }
2214 void setDefaulted(bool D = true) { FunctionDeclBits.IsDefaulted = D; }
2215
2216 /// Whether this function is explicitly defaulted.
2217 bool isExplicitlyDefaulted() const {
2218 return FunctionDeclBits.IsExplicitlyDefaulted;
2219 }
2220
2221 /// State that this function is explicitly defaulted.
2222 void setExplicitlyDefaulted(bool ED = true) {
2223 FunctionDeclBits.IsExplicitlyDefaulted = ED;
2224 }
2225
2226 /// True if this method is user-declared and was not
2227 /// deleted or defaulted on its first declaration.
2228 bool isUserProvided() const {
2229 auto *DeclAsWritten = this;
2230 if (FunctionDecl *Pattern = getTemplateInstantiationPattern())
2231 DeclAsWritten = Pattern;
2232 return !(DeclAsWritten->isDeleted() ||
2233 DeclAsWritten->getCanonicalDecl()->isDefaulted());
2234 }
2235
2236 /// Whether falling off this function implicitly returns null/zero.
2237 /// If a more specific implicit return value is required, front-ends
2238 /// should synthesize the appropriate return statements.
2239 bool hasImplicitReturnZero() const {
2240 return FunctionDeclBits.HasImplicitReturnZero;
2241 }
2242
2243 /// State that falling off this function implicitly returns null/zero.
2244 /// If a more specific implicit return value is required, front-ends
2245 /// should synthesize the appropriate return statements.
2246 void setHasImplicitReturnZero(bool IRZ) {
2247 FunctionDeclBits.HasImplicitReturnZero = IRZ;
2248 }
2249
2250 /// Whether this function has a prototype, either because one
2251 /// was explicitly written or because it was "inherited" by merging
2252 /// a declaration without a prototype with a declaration that has a
2253 /// prototype.
2254 bool hasPrototype() const {
2255 return hasWrittenPrototype() || hasInheritedPrototype();
2256 }
2257
2258 /// Whether this function has a written prototype.
2259 bool hasWrittenPrototype() const {
2260 return FunctionDeclBits.HasWrittenPrototype;
2261 }
2262
2263 /// State that this function has a written prototype.
2264 void setHasWrittenPrototype(bool P = true) {
2265 FunctionDeclBits.HasWrittenPrototype = P;
2266 }
2267
2268 /// Whether this function inherited its prototype from a
2269 /// previous declaration.
2270 bool hasInheritedPrototype() const {
2271 return FunctionDeclBits.HasInheritedPrototype;
2272 }
2273
2274 /// State that this function inherited its prototype from a
2275 /// previous declaration.
2276 void setHasInheritedPrototype(bool P = true) {
2277 FunctionDeclBits.HasInheritedPrototype = P;
2278 }
2279
2280 /// Whether this is a (C++11) constexpr function or constexpr constructor.
2281 bool isConstexpr() const {
2282 return getConstexprKind() != ConstexprSpecKind::Unspecified;
2283 }
2284 void setConstexprKind(ConstexprSpecKind CSK) {
2285 FunctionDeclBits.ConstexprKind = static_cast<uint64_t>(CSK);
2286 }
2287 ConstexprSpecKind getConstexprKind() const {
2288 return static_cast<ConstexprSpecKind>(FunctionDeclBits.ConstexprKind);
2289 }
2290 bool isConstexprSpecified() const {
2291 return getConstexprKind() == ConstexprSpecKind::Constexpr;
2292 }
2293 bool isConsteval() const {
2294 return getConstexprKind() == ConstexprSpecKind::Consteval;
2295 }
2296
2297 /// Whether the instantiation of this function is pending.
2298 /// This bit is set when the decision to instantiate this function is made
2299 /// and unset if and when the function body is created. That leaves out
2300 /// cases where instantiation did not happen because the template definition
2301 /// was not seen in this TU. This bit remains set in those cases, under the
2302 /// assumption that the instantiation will happen in some other TU.
2303 bool instantiationIsPending() const {
2304 return FunctionDeclBits.InstantiationIsPending;
2305 }
2306
2307 /// State that the instantiation of this function is pending.
2308 /// (see instantiationIsPending)
2309 void setInstantiationIsPending(bool IC) {
2310 FunctionDeclBits.InstantiationIsPending = IC;
2311 }
2312
2313 /// Indicates the function uses __try.
2314 bool usesSEHTry() const { return FunctionDeclBits.UsesSEHTry; }
2315 void setUsesSEHTry(bool UST) { FunctionDeclBits.UsesSEHTry = UST; }
2316
2317 /// Whether this function has been deleted.
2318 ///
2319 /// A function that is "deleted" (via the C++0x "= delete" syntax)
2320 /// acts like a normal function, except that it cannot actually be
2321 /// called or have its address taken. Deleted functions are
2322 /// typically used in C++ overload resolution to attract arguments
2323 /// whose type or lvalue/rvalue-ness would permit the use of a
2324 /// different overload that would behave incorrectly. For example,
2325 /// one might use deleted functions to ban implicit conversion from
2326 /// a floating-point number to an Integer type:
2327 ///
2328 /// @code
2329 /// struct Integer {
2330 /// Integer(long); // construct from a long
2331 /// Integer(double) = delete; // no construction from float or double
2332 /// Integer(long double) = delete; // no construction from long double
2333 /// };
2334 /// @endcode
2335 // If a function is deleted, its first declaration must be.
2336 bool isDeleted() const {
2337 return getCanonicalDecl()->FunctionDeclBits.IsDeleted;
2338 }
2339
2340 bool isDeletedAsWritten() const {
2341 return FunctionDeclBits.IsDeleted && !isDefaulted();
2342 }
2343
2344 void setDeletedAsWritten(bool D = true) { FunctionDeclBits.IsDeleted = D; }
2345
2346 /// Determines whether this function is "main", which is the
2347 /// entry point into an executable program.
2348 bool isMain() const;
2349
2350 /// Determines whether this function is a MSVCRT user defined entry
2351 /// point.
2352 bool isMSVCRTEntryPoint() const;
2353
2354 /// Determines whether this operator new or delete is one
2355 /// of the reserved global placement operators:
2356 /// void *operator new(size_t, void *);
2357 /// void *operator new[](size_t, void *);
2358 /// void operator delete(void *, void *);
2359 /// void operator delete[](void *, void *);
2360 /// These functions have special behavior under [new.delete.placement]:
2361 /// These functions are reserved, a C++ program may not define
2362 /// functions that displace the versions in the Standard C++ library.
2363 /// The provisions of [basic.stc.dynamic] do not apply to these
2364 /// reserved placement forms of operator new and operator delete.
2365 ///
2366 /// This function must be an allocation or deallocation function.
2367 bool isReservedGlobalPlacementOperator() const;
2368
2369 /// Determines whether this function is one of the replaceable
2370 /// global allocation functions:
2371 /// void *operator new(size_t);
2372 /// void *operator new(size_t, const std::nothrow_t &) noexcept;
2373 /// void *operator new[](size_t);
2374 /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
2375 /// void operator delete(void *) noexcept;
2376 /// void operator delete(void *, std::size_t) noexcept; [C++1y]
2377 /// void operator delete(void *, const std::nothrow_t &) noexcept;
2378 /// void operator delete[](void *) noexcept;
2379 /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
2380 /// void operator delete[](void *, const std::nothrow_t &) noexcept;
2381 /// These functions have special behavior under C++1y [expr.new]:
2382 /// An implementation is allowed to omit a call to a replaceable global
2383 /// allocation function. [...]
2384 ///
2385 /// If this function is an aligned allocation/deallocation function, return
2386 /// the parameter number of the requested alignment through AlignmentParam.
2387 ///
2388 /// If this function is an allocation/deallocation function that takes
2389 /// the `std::nothrow_t` tag, return true through IsNothrow,
2390 bool isReplaceableGlobalAllocationFunction(
2391 Optional<unsigned> *AlignmentParam = nullptr,
2392 bool *IsNothrow = nullptr) const;
2393
2394 /// Determine if this function provides an inline implementation of a builtin.
2395 bool isInlineBuiltinDeclaration() const;
2396
2397 /// Determine whether this is a destroying operator delete.
2398 bool isDestroyingOperatorDelete() const;
2399
2400 /// Compute the language linkage.
2401 LanguageLinkage getLanguageLinkage() const;
2402
2403 /// Determines whether this function is a function with
2404 /// external, C linkage.
2405 bool isExternC() const;
2406
2407 /// Determines whether this function's context is, or is nested within,
2408 /// a C++ extern "C" linkage spec.
2409 bool isInExternCContext() const;
2410
2411 /// Determines whether this function's context is, or is nested within,
2412 /// a C++ extern "C++" linkage spec.
2413 bool isInExternCXXContext() const;
2414
2415 /// Determines whether this is a global function.
2416 bool isGlobal() const;
2417
2418 /// Determines whether this function is known to be 'noreturn', through
2419 /// an attribute on its declaration or its type.
2420 bool isNoReturn() const;
2421
2422 /// True if the function was a definition but its body was skipped.
2423 bool hasSkippedBody() const { return FunctionDeclBits.HasSkippedBody; }
2424 void setHasSkippedBody(bool Skipped = true) {
2425 FunctionDeclBits.HasSkippedBody = Skipped;
2426 }
2427
2428 /// True if this function will eventually have a body, once it's fully parsed.
2429 bool willHaveBody() const { return FunctionDeclBits.WillHaveBody; }
2430 void setWillHaveBody(bool V = true) { FunctionDeclBits.WillHaveBody = V; }
2431
2432 /// True if this function is considered a multiversioned function.
2433 bool isMultiVersion() const {
2434 return getCanonicalDecl()->FunctionDeclBits.IsMultiVersion;
2435 }
2436
2437 /// Sets the multiversion state for this declaration and all of its
2438 /// redeclarations.
2439 void setIsMultiVersion(bool V = true) {
2440 getCanonicalDecl()->FunctionDeclBits.IsMultiVersion = V;
2441 }
2442
2443 /// Gets the kind of multiversioning attribute this declaration has. Note that
2444 /// this can return a value even if the function is not multiversion, such as
2445 /// the case of 'target'.
2446 MultiVersionKind getMultiVersionKind() const;
2447
2448
2449 /// True if this function is a multiversioned dispatch function as a part of
2450 /// the cpu_specific/cpu_dispatch functionality.
2451 bool isCPUDispatchMultiVersion() const;
2452 /// True if this function is a multiversioned processor specific function as a
2453 /// part of the cpu_specific/cpu_dispatch functionality.
2454 bool isCPUSpecificMultiVersion() const;
2455
2456 /// True if this function is a multiversioned dispatch function as a part of
2457 /// the target functionality.
2458 bool isTargetMultiVersion() const;
2459
2460 /// \brief Get the associated-constraints of this function declaration.
2461 /// Currently, this will either be a vector of size 1 containing the
2462 /// trailing-requires-clause or an empty vector.
2463 ///
2464 /// Use this instead of getTrailingRequiresClause for concepts APIs that
2465 /// accept an ArrayRef of constraint expressions.
2466 void getAssociatedConstraints(SmallVectorImpl<const Expr *> &AC) const {
2467 if (auto *TRC = getTrailingRequiresClause())
2468 AC.push_back(TRC);
2469 }
2470
2471 void setPreviousDeclaration(FunctionDecl * PrevDecl);
2472
2473 FunctionDecl *getCanonicalDecl() override;
2474 const FunctionDecl *getCanonicalDecl() const {
2475 return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
2476 }
2477
2478 unsigned getBuiltinID(bool ConsiderWrapperFunctions = false) const;
2479
2480 // ArrayRef interface to parameters.
2481 ArrayRef<ParmVarDecl *> parameters() const {
2482 return {ParamInfo, getNumParams()};
2483 }
2484 MutableArrayRef<ParmVarDecl *> parameters() {
2485 return {ParamInfo, getNumParams()};
2486 }
2487
2488 // Iterator access to formal parameters.
2489 using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
2490 using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
2491
2492 bool param_empty() const { return parameters().empty(); }
2493 param_iterator param_begin() { return parameters().begin(); }
2494 param_iterator param_end() { return parameters().end(); }
2495 param_const_iterator param_begin() const { return parameters().begin(); }
2496 param_const_iterator param_end() const { return parameters().end(); }
2497 size_t param_size() const { return parameters().size(); }
2498
2499 /// Return the number of parameters this function must have based on its
2500 /// FunctionType. This is the length of the ParamInfo array after it has been
2501 /// created.
2502 unsigned getNumParams() const;
2503
2504 const ParmVarDecl *getParamDecl(unsigned i) const {
2505 assert(i < getNumParams() && "Illegal param #")((void)0);
2506 return ParamInfo[i];
2507 }
2508 ParmVarDecl *getParamDecl(unsigned i) {
2509 assert(i < getNumParams() && "Illegal param #")((void)0);
2510 return ParamInfo[i];
2511 }
2512 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
2513 setParams(getASTContext(), NewParamInfo);
2514 }
2515
2516 /// Returns the minimum number of arguments needed to call this function. This
2517 /// may be fewer than the number of function parameters, if some of the
2518 /// parameters have default arguments (in C++).
2519 unsigned getMinRequiredArguments() const;
2520
2521 /// Determine whether this function has a single parameter, or multiple
2522 /// parameters where all but the first have default arguments.
2523 ///
2524 /// This notion is used in the definition of copy/move constructors and
2525 /// initializer list constructors. Note that, unlike getMinRequiredArguments,
2526 /// parameter packs are not treated specially here.
2527 bool hasOneParamOrDefaultArgs() const;
2528
2529 /// Find the source location information for how the type of this function
2530 /// was written. May be absent (for example if the function was declared via
2531 /// a typedef) and may contain a different type from that of the function
2532 /// (for example if the function type was adjusted by an attribute).
2533 FunctionTypeLoc getFunctionTypeLoc() const;
2534
2535 QualType getReturnType() const {
2536 return getType()->castAs<FunctionType>()->getReturnType();
2537 }
2538
2539 /// Attempt to compute an informative source range covering the
2540 /// function return type. This may omit qualifiers and other information with
2541 /// limited representation in the AST.
2542 SourceRange getReturnTypeSourceRange() const;
2543
2544 /// Attempt to compute an informative source range covering the
2545 /// function parameters, including the ellipsis of a variadic function.
2546 /// The source range excludes the parentheses, and is invalid if there are
2547 /// no parameters and no ellipsis.
2548 SourceRange getParametersSourceRange() const;
2549
2550 /// Get the declared return type, which may differ from the actual return
2551 /// type if the return type is deduced.
2552 QualType getDeclaredReturnType() const {
2553 auto *TSI = getTypeSourceInfo();
2554 QualType T = TSI ? TSI->getType() : getType();
2555 return T->castAs<FunctionType>()->getReturnType();
2556 }
2557
2558 /// Gets the ExceptionSpecificationType as declared.
2559 ExceptionSpecificationType getExceptionSpecType() const {
2560 auto *TSI = getTypeSourceInfo();
2561 QualType T = TSI ? TSI->getType() : getType();
2562 const auto *FPT = T->getAs<FunctionProtoType>();
2563 return FPT ? FPT->getExceptionSpecType() : EST_None;
2564 }
2565
2566 /// Attempt to compute an informative source range covering the
2567 /// function exception specification, if any.
2568 SourceRange getExceptionSpecSourceRange() const;
2569
2570 /// Determine the type of an expression that calls this function.
2571 QualType getCallResultType() const {
2572 return getType()->castAs<FunctionType>()->getCallResultType(
2573 getASTContext());
2574 }
2575
2576 /// Returns the storage class as written in the source. For the
2577 /// computed linkage of symbol, see getLinkage.
2578 StorageClass getStorageClass() const {
2579 return static_cast<StorageClass>(FunctionDeclBits.SClass);
2580 }
2581
2582 /// Sets the storage class as written in the source.
2583 void setStorageClass(StorageClass SClass) {
2584 FunctionDeclBits.SClass = SClass;
2585 }
2586
2587 /// Determine whether the "inline" keyword was specified for this
2588 /// function.
2589 bool isInlineSpecified() const { return FunctionDeclBits.IsInlineSpecified; }
2590
2591 /// Set whether the "inline" keyword was specified for this function.
2592 void setInlineSpecified(bool I) {
2593 FunctionDeclBits.IsInlineSpecified = I;
2594 FunctionDeclBits.IsInline = I;
2595 }
2596
2597 /// Flag that this function is implicitly inline.
2598 void setImplicitlyInline(bool I = true) { FunctionDeclBits.IsInline = I; }
2599
2600 /// Determine whether this function should be inlined, because it is
2601 /// either marked "inline" or "constexpr" or is a member function of a class
2602 /// that was defined in the class body.
2603 bool isInlined() const { return FunctionDeclBits.IsInline; }
2604
2605 bool isInlineDefinitionExternallyVisible() const;
2606
2607 bool isMSExternInline() const;
2608
2609 bool doesDeclarationForceExternallyVisibleDefinition() const;
2610
2611 bool isStatic() const { return getStorageClass() == SC_Static; }
2612
2613 /// Whether this function declaration represents an C++ overloaded
2614 /// operator, e.g., "operator+".
2615 bool isOverloadedOperator() const {
2616 return getOverloadedOperator() != OO_None;
2617 }
2618
2619 OverloadedOperatorKind getOverloadedOperator() const;
2620
2621 const IdentifierInfo *getLiteralIdentifier() const;
2622
2623 /// If this function is an instantiation of a member function
2624 /// of a class template specialization, retrieves the function from
2625 /// which it was instantiated.
2626 ///
2627 /// This routine will return non-NULL for (non-templated) member
2628 /// functions of class templates and for instantiations of function
2629 /// templates. For example, given:
2630 ///
2631 /// \code
2632 /// template<typename T>
2633 /// struct X {
2634 /// void f(T);
2635 /// };
2636 /// \endcode
2637 ///
2638 /// The declaration for X<int>::f is a (non-templated) FunctionDecl
2639 /// whose parent is the class template specialization X<int>. For
2640 /// this declaration, getInstantiatedFromFunction() will return
2641 /// the FunctionDecl X<T>::A. When a complete definition of
2642 /// X<int>::A is required, it will be instantiated from the
2643 /// declaration returned by getInstantiatedFromMemberFunction().
2644 FunctionDecl *getInstantiatedFromMemberFunction() const;
2645
2646 /// What kind of templated function this is.
2647 TemplatedKind getTemplatedKind() const;
2648
2649 /// If this function is an instantiation of a member function of a
2650 /// class template specialization, retrieves the member specialization
2651 /// information.
2652 MemberSpecializationInfo *getMemberSpecializationInfo() const;
2653
2654 /// Specify that this record is an instantiation of the
2655 /// member function FD.
2656 void setInstantiationOfMemberFunction(FunctionDecl *FD,
2657 TemplateSpecializationKind TSK) {
2658 setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
2659 }
2660
2661 /// Retrieves the function template that is described by this
2662 /// function declaration.
2663 ///
2664 /// Every function template is represented as a FunctionTemplateDecl
2665 /// and a FunctionDecl (or something derived from FunctionDecl). The
2666 /// former contains template properties (such as the template
2667 /// parameter lists) while the latter contains the actual
2668 /// description of the template's
2669 /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
2670 /// FunctionDecl that describes the function template,
2671 /// getDescribedFunctionTemplate() retrieves the
2672 /// FunctionTemplateDecl from a FunctionDecl.
2673 FunctionTemplateDecl *getDescribedFunctionTemplate() const;
2674
2675 void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);
2676
2677 /// Determine whether this function is a function template
2678 /// specialization.
2679 bool isFunctionTemplateSpecialization() const {
2680 return getPrimaryTemplate() != nullptr;
2681 }
2682
2683 /// If this function is actually a function template specialization,
2684 /// retrieve information about this function template specialization.
2685 /// Otherwise, returns NULL.
2686 FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;
2687
2688 /// Determines whether this function is a function template
2689 /// specialization or a member of a class template specialization that can
2690 /// be implicitly instantiated.
2691 bool isImplicitlyInstantiable() const;
2692
2693 /// Determines if the given function was instantiated from a
2694 /// function template.
2695 bool isTemplateInstantiation() const;
2696
2697 /// Retrieve the function declaration from which this function could
2698 /// be instantiated, if it is an instantiation (rather than a non-template
2699 /// or a specialization, for example).
2700 ///
2701 /// If \p ForDefinition is \c false, explicit specializations will be treated
2702 /// as if they were implicit instantiations. This will then find the pattern
2703 /// corresponding to non-definition portions of the declaration, such as
2704 /// default arguments and the exception specification.
2705 FunctionDecl *
2706 getTemplateInstantiationPattern(bool ForDefinition = true) const;
2707
2708 /// Retrieve the primary template that this function template
2709 /// specialization either specializes or was instantiated from.
2710 ///
2711 /// If this function declaration is not a function template specialization,
2712 /// returns NULL.
2713 FunctionTemplateDecl *getPrimaryTemplate() const;
2714
2715 /// Retrieve the template arguments used to produce this function
2716 /// template specialization from the primary template.
2717 ///
2718 /// If this function declaration is not a function template specialization,
2719 /// returns NULL.
2720 const TemplateArgumentList *getTemplateSpecializationArgs() const;
2721
2722 /// Retrieve the template argument list as written in the sources,
2723 /// if any.
2724 ///
2725 /// If this function declaration is not a function template specialization
2726 /// or if it had no explicit template argument list, returns NULL.
2727 /// Note that it an explicit template argument list may be written empty,
2728 /// e.g., template<> void foo<>(char* s);
2729 const ASTTemplateArgumentListInfo*
2730 getTemplateSpecializationArgsAsWritten() const;
2731
2732 /// Specify that this function declaration is actually a function
2733 /// template specialization.
2734 ///
2735 /// \param Template the function template that this function template
2736 /// specialization specializes.
2737 ///
2738 /// \param TemplateArgs the template arguments that produced this
2739 /// function template specialization from the template.
2740 ///
2741 /// \param InsertPos If non-NULL, the position in the function template
2742 /// specialization set where the function template specialization data will
2743 /// be inserted.
2744 ///
2745 /// \param TSK the kind of template specialization this is.
2746 ///
2747 /// \param TemplateArgsAsWritten location info of template arguments.
2748 ///
2749 /// \param PointOfInstantiation point at which the function template
2750 /// specialization was first instantiated.
2751 void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
2752 const TemplateArgumentList *TemplateArgs,
2753 void *InsertPos,
2754 TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
2755 const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2756 SourceLocation PointOfInstantiation = SourceLocation()) {
2757 setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2758 InsertPos, TSK, TemplateArgsAsWritten,
2759 PointOfInstantiation);
2760 }
2761
2762 /// Specifies that this function declaration is actually a
2763 /// dependent function template specialization.
2764 void setDependentTemplateSpecialization(ASTContext &Context,
2765 const UnresolvedSetImpl &Templates,
2766 const TemplateArgumentListInfo &TemplateArgs);
2767
2768 DependentFunctionTemplateSpecializationInfo *
2769 getDependentSpecializationInfo() const;
2770
2771 /// Determine what kind of template instantiation this function
2772 /// represents.
2773 TemplateSpecializationKind getTemplateSpecializationKind() const;
2774
2775 /// Determine the kind of template specialization this function represents
2776 /// for the purpose of template instantiation.
2777 TemplateSpecializationKind
2778 getTemplateSpecializationKindForInstantiation() const;
2779
2780 /// Determine what kind of template instantiation this function
2781 /// represents.
2782 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2783 SourceLocation PointOfInstantiation = SourceLocation());
2784
2785 /// Retrieve the (first) point of instantiation of a function template
2786 /// specialization or a member of a class template specialization.
2787 ///
2788 /// \returns the first point of instantiation, if this function was
2789 /// instantiated from a template; otherwise, returns an invalid source
2790 /// location.
2791 SourceLocation getPointOfInstantiation() const;
2792
2793 /// Determine whether this is or was instantiated from an out-of-line
2794 /// definition of a member function.
2795 bool isOutOfLine() const override;
2796
2797 /// Identify a memory copying or setting function.
2798 /// If the given function is a memory copy or setting function, returns
2799 /// the corresponding Builtin ID. If the function is not a memory function,
2800 /// returns 0.
2801 unsigned getMemoryFunctionKind() const;
2802
2803 /// Returns ODRHash of the function. This value is calculated and
2804 /// stored on first call, then the stored value returned on the other calls.
2805 unsigned getODRHash();
2806
2807 /// Returns cached ODRHash of the function. This must have been previously
2808 /// computed and stored.
2809 unsigned getODRHash() const;
2810
2811 // Implement isa/cast/dyncast/etc.
2812 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2813 static bool classofKind(Kind K) {
2814 return K >= firstFunction && K <= lastFunction;
2815 }
2816 static DeclContext *castToDeclContext(const FunctionDecl *D) {
2817 return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2818 }
2819 static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
2820 return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2821 }
2822};
2823
2824/// Represents a member of a struct/union/class.
2825class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2826 unsigned BitField : 1;
2827 unsigned Mutable : 1;
2828 mutable unsigned CachedFieldIndex : 30;
2829
2830 /// The kinds of value we can store in InitializerOrBitWidth.
2831 ///
2832 /// Note that this is compatible with InClassInitStyle except for
2833 /// ISK_CapturedVLAType.
2834 enum InitStorageKind {
2835 /// If the pointer is null, there's nothing special. Otherwise,
2836 /// this is a bitfield and the pointer is the Expr* storing the
2837 /// bit-width.
2838 ISK_NoInit = (unsigned) ICIS_NoInit,
2839
2840 /// The pointer is an (optional due to delayed parsing) Expr*
2841 /// holding the copy-initializer.
2842 ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,
2843
2844 /// The pointer is an (optional due to delayed parsing) Expr*
2845 /// holding the list-initializer.
2846 ISK_InClassListInit = (unsigned) ICIS_ListInit,
2847
2848 /// The pointer is a VariableArrayType* that's been captured;
2849 /// the enclosing context is a lambda or captured statement.
2850 ISK_CapturedVLAType,
2851 };
2852
2853 /// If this is a bitfield with a default member initializer, this
2854 /// structure is used to represent the two expressions.
2855 struct InitAndBitWidth {
2856 Expr *Init;
2857 Expr *BitWidth;
2858 };
2859
2860 /// Storage for either the bit-width, the in-class initializer, or
2861 /// both (via InitAndBitWidth), or the captured variable length array bound.
2862 ///
2863 /// If the storage kind is ISK_InClassCopyInit or
2864 /// ISK_InClassListInit, but the initializer is null, then this
2865 /// field has an in-class initializer that has not yet been parsed
2866 /// and attached.
2867 // FIXME: Tail-allocate this to reduce the size of FieldDecl in the
2868 // overwhelmingly common case that we have none of these things.
2869 llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2870
2871protected:
2872 FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
2873 SourceLocation IdLoc, IdentifierInfo *Id,
2874 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2875 InClassInitStyle InitStyle)
2876 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2877 BitField(false), Mutable(Mutable), CachedFieldIndex(0),
2878 InitStorage(nullptr, (InitStorageKind) InitStyle) {
2879 if (BW)
2880 setBitWidth(BW);
2881 }
2882
2883public:
2884 friend class ASTDeclReader;
2885 friend class ASTDeclWriter;
2886
2887 static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
2888 SourceLocation StartLoc, SourceLocation IdLoc,
2889 IdentifierInfo *Id, QualType T,
2890 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2891 InClassInitStyle InitStyle);
2892
2893 static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2894
2895 /// Returns the index of this field within its record,
2896 /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
2897 unsigned getFieldIndex() const;
2898
2899 /// Determines whether this field is mutable (C++ only).
2900 bool isMutable() const { return Mutable; }
2901
2902 /// Determines whether this field is a bitfield.
2903 bool isBitField() const { return BitField; }
2904
2905 /// Determines whether this is an unnamed bitfield.
2906 bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
2907
2908 /// Determines whether this field is a
2909 /// representative for an anonymous struct or union. Such fields are
2910 /// unnamed and are implicitly generated by the implementation to
2911 /// store the data for the anonymous union or struct.
2912 bool isAnonymousStructOrUnion() const;
2913
2914 Expr *getBitWidth() const {
2915 if (!BitField)
2916 return nullptr;
2917 void *Ptr = InitStorage.getPointer();
2918 if (getInClassInitStyle())
2919 return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
2920 return static_cast<Expr*>(Ptr);
2921 }
2922
2923 unsigned getBitWidthValue(const ASTContext &Ctx) const;
2924
2925 /// Set the bit-field width for this member.
2926 // Note: used by some clients (i.e., do not remove it).
2927 void setBitWidth(Expr *Width) {
2928 assert(!hasCapturedVLAType() && !BitField &&((void)0)
2929 "bit width or captured type already set")((void)0);
2930 assert(Width && "no bit width specified")((void)0);
2931 InitStorage.setPointer(
2932 InitStorage.getInt()
2933 ? new (getASTContext())
2934 InitAndBitWidth{getInClassInitializer(), Width}
2935 : static_cast<void*>(Width));
2936 BitField = true;
2937 }
2938
2939 /// Remove the bit-field width from this member.
2940 // Note: used by some clients (i.e., do not remove it).
2941 void removeBitWidth() {
2942 assert(isBitField() && "no bitfield width to remove")((void)0);
2943 InitStorage.setPointer(getInClassInitializer());
2944 BitField = false;
2945 }
2946
2947 /// Is this a zero-length bit-field? Such bit-fields aren't really bit-fields
2948 /// at all and instead act as a separator between contiguous runs of other
2949 /// bit-fields.
2950 bool isZeroLengthBitField(const ASTContext &Ctx) const;
2951
2952 /// Determine if this field is a subobject of zero size, that is, either a
2953 /// zero-length bit-field or a field of empty class type with the
2954 /// [[no_unique_address]] attribute.
2955 bool isZeroSize(const ASTContext &Ctx) const;
2956
2957 /// Get the kind of (C++11) default member initializer that this field has.
2958 InClassInitStyle getInClassInitStyle() const {
2959 InitStorageKind storageKind = InitStorage.getInt();
2960 return (storageKind == ISK_CapturedVLAType
2961 ? ICIS_NoInit : (InClassInitStyle) storageKind);
2962 }
2963
2964 /// Determine whether this member has a C++11 default member initializer.
2965 bool hasInClassInitializer() const {
2966 return getInClassInitStyle() != ICIS_NoInit;
2967 }
2968
2969 /// Get the C++11 default member initializer for this member, or null if one
2970 /// has not been set. If a valid declaration has a default member initializer,
2971 /// but this returns null, then we have not parsed and attached it yet.
2972 Expr *getInClassInitializer() const {
2973 if (!hasInClassInitializer())
2974 return nullptr;
2975 void *Ptr = InitStorage.getPointer();
2976 if (BitField)
2977 return static_cast<InitAndBitWidth*>(Ptr)->Init;
2978 return static_cast<Expr*>(Ptr);
2979 }
2980
2981 /// Set the C++11 in-class initializer for this member.
2982 void setInClassInitializer(Expr *Init) {
2983 assert(hasInClassInitializer() && !getInClassInitializer())((void)0);
2984 if (BitField)
2985 static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
2986 else
2987 InitStorage.setPointer(Init);
2988 }
2989
2990 /// Remove the C++11 in-class initializer from this member.
2991 void removeInClassInitializer() {
2992 assert(hasInClassInitializer() && "no initializer to remove")((void)0);
2993 InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
2994 }
2995
2996 /// Determine whether this member captures the variable length array
2997 /// type.
2998 bool hasCapturedVLAType() const {
2999 return InitStorage.getInt() == ISK_CapturedVLAType;
3000 }
3001
3002 /// Get the captured variable length array type.
3003 const VariableArrayType *getCapturedVLAType() const {
3004 return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
3005 InitStorage.getPointer())
3006 : nullptr;
3007 }
3008
3009 /// Set the captured variable length array type for this field.
3010 void setCapturedVLAType(const VariableArrayType *VLAType);
3011
3012 /// Returns the parent of this field declaration, which
3013 /// is the struct in which this field is defined.
3014 ///
3015 /// Returns null if this is not a normal class/struct field declaration, e.g.
3016 /// ObjCAtDefsFieldDecl, ObjCIvarDecl.
3017 const RecordDecl *getParent() const {
3018 return dyn_cast<RecordDecl>(getDeclContext());
3019 }
3020
3021 RecordDecl *getParent() {
3022 return dyn_cast<RecordDecl>(getDeclContext());
3023 }
3024
3025 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3026
3027 /// Retrieves the canonical declaration of this field.
3028 FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
3029 const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
3030
3031 // Implement isa/cast/dyncast/etc.
3032 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3033 static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
3034};
3035
3036/// An instance of this object exists for each enum constant
3037/// that is defined. For example, in "enum X {a,b}", each of a/b are
3038/// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
3039/// TagType for the X EnumDecl.
3040class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
3041 Stmt *Init; // an integer constant expression
3042 llvm::APSInt Val; // The value.
3043
3044protected:
3045 EnumConstantDecl(DeclContext *DC, SourceLocation L,
3046 IdentifierInfo *Id, QualType T, Expr *E,
3047 const llvm::APSInt &V)
3048 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
3049
3050public:
3051 friend class StmtIteratorBase;
3052
3053 static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
3054 SourceLocation L, IdentifierInfo *Id,
3055 QualType T, Expr *E,
3056 const llvm::APSInt &V);
3057 static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3058
3059 const Expr *getInitExpr() const { return (const Expr*) Init; }
3060 Expr *getInitExpr() { return (Expr*) Init; }
3061 const llvm::APSInt &getInitVal() const { return Val; }
3062
3063 void setInitExpr(Expr *E) { Init = (Stmt*) E; }
3064 void setInitVal(const llvm::APSInt &V) { Val = V; }
3065
3066 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3067
3068 /// Retrieves the canonical declaration of this enumerator.
3069 EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
3070 const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
3071
3072 // Implement isa/cast/dyncast/etc.
3073 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3074 static bool classofKind(Kind K) { return K == EnumConstant; }
3075};
3076
3077/// Represents a field injected from an anonymous union/struct into the parent
3078/// scope. These are always implicit.
3079class IndirectFieldDecl : public ValueDecl,
3080 public Mergeable<IndirectFieldDecl> {
3081 NamedDecl **Chaining;
3082 unsigned ChainingSize;
3083
3084 IndirectFieldDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
3085 DeclarationName N, QualType T,
3086 MutableArrayRef<NamedDecl *> CH);
3087
3088 void anchor() override;
3089
3090public:
3091 friend class ASTDeclReader;
3092
3093 static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
3094 SourceLocation L, IdentifierInfo *Id,
3095 QualType T, llvm::MutableArrayRef<NamedDecl *> CH);
3096
3097 static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3098
3099 using chain_iterator = ArrayRef<NamedDecl *>::const_iterator;
3100
3101 ArrayRef<NamedDecl *> chain() const {
3102 return llvm::makeArrayRef(Chaining, ChainingSize);
3103 }
3104 chain_iterator chain_begin() const { return chain().begin(); }
3105 chain_iterator chain_end() const { return chain().end(); }
3106
3107 unsigned getChainingSize() const { return ChainingSize; }
3108
3109 FieldDecl *getAnonField() const {
3110 assert(chain().size() >= 2)((void)0);
3111 return cast<FieldDecl>(chain().back());
3112 }
3113
3114 VarDecl *getVarDecl() const {
3115 assert(chain().size() >= 2)((void)0);
3116 return dyn_cast<VarDecl>(chain().front());
3117 }
3118
3119 IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
3120 const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
3121
3122 // Implement isa/cast/dyncast/etc.
3123 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3124 static bool classofKind(Kind K) { return K == IndirectField; }
3125};
3126
3127/// Represents a declaration of a type.
3128class TypeDecl : public NamedDecl {
3129 friend class ASTContext;
3130
3131 /// This indicates the Type object that represents
3132 /// this TypeDecl. It is a cache maintained by
3133 /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
3134 /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
3135 mutable const Type *TypeForDecl = nullptr;
3136
3137 /// The start of the source range for this declaration.
3138 SourceLocation LocStart;
3139
3140 void anchor() override;
3141
3142protected:
3143 TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
3144 SourceLocation StartL = SourceLocation())
3145 : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}
3146
3147public:
3148 // Low-level accessor. If you just want the type defined by this node,
3149 // check out ASTContext::getTypeDeclType or one of
3150 // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
3151 // already know the specific kind of node this is.
3152 const Type *getTypeForDecl() const { return TypeForDecl; }
3153 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
3154
3155 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
3156 void setLocStart(SourceLocation L) { LocStart = L; }
3157 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
3158 if (LocStart.isValid())
3159 return SourceRange(LocStart, getLocation());
3160 else
3161 return SourceRange(getLocation());
3162 }
3163
3164 // Implement isa/cast/dyncast/etc.
3165 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3166 static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
3167};
3168
3169/// Base class for declarations which introduce a typedef-name.
3170class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
3171 struct alignas(8) ModedTInfo {
3172 TypeSourceInfo *first;
3173 QualType second;
3174 };
3175
3176 /// If int part is 0, we have not computed IsTransparentTag.
3177 /// Otherwise, IsTransparentTag is (getInt() >> 1).
3178 mutable llvm::PointerIntPair<
3179 llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
3180 MaybeModedTInfo;
3181
3182 void anchor() override;
3183
3184protected:
3185 TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
3186 SourceLocation StartLoc, SourceLocation IdLoc,
3187 IdentifierInfo *Id, TypeSourceInfo *TInfo)
3188 : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
3189 MaybeModedTInfo(TInfo, 0) {}
3190
3191 using redeclarable_base = Redeclarable<TypedefNameDecl>;
3192
3193 TypedefNameDecl *getNextRedeclarationImpl() override {
3194 return getNextRedeclaration();
3195 }
3196
3197 TypedefNameDecl *getPreviousDeclImpl() override {
3198 return getPreviousDecl();
3199 }
3200
3201 TypedefNameDecl *getMostRecentDeclImpl() override {
3202 return getMostRecentDecl();
3203 }
3204
3205public:
3206 using redecl_range = redeclarable_base::redecl_range;
3207 using redecl_iterator = redeclarable_base::redecl_iterator;
3208
3209 using redeclarable_base::redecls_begin;
3210 using redeclarable_base::redecls_end;
3211 using redeclarable_base::redecls;
3212 using redeclarable_base::getPreviousDecl;
3213 using redeclarable_base::getMostRecentDecl;
3214 using redeclarable_base::isFirstDecl;
3215
3216 bool isModed() const {
3217 return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
3218 }
3219
3220 TypeSourceInfo *getTypeSourceInfo() const {
3221 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
3222 : MaybeModedTInfo.getPointer().get<TypeSourceInfo *>();
3223 }
3224
3225 QualType getUnderlyingType() const {
3226 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
3227 : MaybeModedTInfo.getPointer()
3228 .get<TypeSourceInfo *>()
3229 ->getType();
3230 }
3231
3232 void setTypeSourceInfo(TypeSourceInfo *newType) {
3233 MaybeModedTInfo.setPointer(newType);
3234 }
3235
3236 void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
3237 MaybeModedTInfo.setPointer(new (getASTContext(), 8)
3238 ModedTInfo({unmodedTSI, modedTy}));
3239 }
3240
3241 /// Retrieves the canonical declaration of this typedef-name.
3242 TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
3243 const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
3244
3245 /// Retrieves the tag declaration for which this is the typedef name for
3246 /// linkage purposes, if any.
3247 ///
3248 /// \param AnyRedecl Look for the tag declaration in any redeclaration of
3249 /// this typedef declaration.
3250 TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;
3251
3252 /// Determines if this typedef shares a name and spelling location with its
3253 /// underlying tag type, as is the case with the NS_ENUM macro.
3254 bool isTransparentTag() const {
3255 if (MaybeModedTInfo.getInt())
3256 return MaybeModedTInfo.getInt() & 0x2;
3257 return isTransparentTagSlow();
3258 }
3259
3260 // Implement isa/cast/dyncast/etc.
3261 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3262 static bool classofKind(Kind K) {
3263 return K >= firstTypedefName && K <= lastTypedefName;
3264 }
3265
3266private:
3267 bool isTransparentTagSlow() const;
3268};
3269
3270/// Represents the declaration of a typedef-name via the 'typedef'
3271/// type specifier.
3272class TypedefDecl : public TypedefNameDecl {
3273 TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3274 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
3275 : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
3276
3277public:
3278 static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
3279 SourceLocation StartLoc, SourceLocation IdLoc,
3280 IdentifierInfo *Id, TypeSourceInfo *TInfo);
3281 static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3282
3283 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3284
3285 // Implement isa/cast/dyncast/etc.
3286 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3287 static bool classofKind(Kind K) { return K == Typedef; }
3288};
3289
3290/// Represents the declaration of a typedef-name via a C++11
3291/// alias-declaration.
3292class TypeAliasDecl : public TypedefNameDecl {
3293 /// The template for which this is the pattern, if any.
3294 TypeAliasTemplateDecl *Template;
3295
3296 TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3297 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
3298 : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
3299 Template(nullptr) {}
3300
3301public:
3302 static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
3303 SourceLocation StartLoc, SourceLocation IdLoc,
3304 IdentifierInfo *Id, TypeSourceInfo *TInfo);
3305 static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3306
3307 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3308
3309 TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
3310 void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }
3311
3312 // Implement isa/cast/dyncast/etc.
3313 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3314 static bool classofKind(Kind K) { return K == TypeAlias; }
3315};
3316
3317/// Represents the declaration of a struct/union/class/enum.
3318class TagDecl : public TypeDecl,
3319 public DeclContext,
3320 public Redeclarable<TagDecl> {
3321 // This class stores some data in DeclContext::TagDeclBits
3322 // to save some space. Use the provided accessors to access it.
3323public:
3324 // This is really ugly.
3325 using TagKind = TagTypeKind;
3326
3327private:
3328 SourceRange BraceRange;
3329
3330 // A struct representing syntactic qualifier info,
3331 // to be used for the (uncommon) case of out-of-line declarations.
3332 using ExtInfo = QualifierInfo;
3333
3334 /// If the (out-of-line) tag declaration name
3335 /// is qualified, it points to the qualifier info (nns and range);
3336 /// otherwise, if the tag declaration is anonymous and it is part of
3337 /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
3338 /// otherwise, if the tag declaration is anonymous and it is used as a
3339 /// declaration specifier for variables, it points to the first VarDecl (used
3340 /// for mangling);
3341 /// otherwise, it is a null (TypedefNameDecl) pointer.
3342 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3343
3344 bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
3345 ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3346 const ExtInfo *getExtInfo() const {
3347 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3348 }
3349
3350protected:
3351 TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3352 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
3353 SourceLocation StartL);
3354
3355 using redeclarable_base = Redeclarable<TagDecl>;
3356
3357 TagDecl *getNextRedeclarationImpl() override {
3358 return getNextRedeclaration();
3359 }
3360
3361 TagDecl *getPreviousDeclImpl() override {
3362 return getPreviousDecl();
3363 }
3364
3365 TagDecl *getMostRecentDeclImpl() override {
3366 return getMostRecentDecl();
3367 }
3368
3369 /// Completes the definition of this tag declaration.
3370 ///
3371 /// This is a helper function for derived classes.
3372 void completeDefinition();
3373
3374 /// True if this decl is currently being defined.
3375 void setBeingDefined(bool V = true) { TagDeclBits.IsBeingDefined = V; }
3376
3377 /// Indicates whether it is possible for declarations of this kind
3378 /// to have an out-of-date definition.
3379 ///
3380 /// This option is only enabled when modules are enabled.
3381 void setMayHaveOutOfDateDef(bool V = true) {
3382 TagDeclBits.MayHaveOutOfDateDef = V;
3383 }
3384
3385public:
3386 friend class ASTDeclReader;
3387 friend class ASTDeclWriter;
3388
3389 using redecl_range = redeclarable_base::redecl_range;
3390 using redecl_iterator = redeclarable_base::redecl_iterator;
3391
3392 using redeclarable_base::redecls_begin;
3393 using redeclarable_base::redecls_end;
3394 using redeclarable_base::redecls;
3395 using redeclarable_base::getPreviousDecl;
3396 using redeclarable_base::getMostRecentDecl;
3397 using redeclarable_base::isFirstDecl;
3398
3399 SourceRange getBraceRange() const { return BraceRange; }
3400 void setBraceRange(SourceRange R) { BraceRange = R; }
3401
3402 /// Return SourceLocation representing start of source
3403 /// range ignoring outer template declarations.
3404 SourceLocation getInnerLocStart() const { return getBeginLoc(); }
3405
3406 /// Return SourceLocation representing start of source
3407 /// range taking into account any outer template declarations.
3408 SourceLocation getOuterLocStart() const;
3409 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3410
3411 TagDecl *getCanonicalDecl() override;
3412 const TagDecl *getCanonicalDecl() const {
3413 return const_cast<TagDecl*>(this)->getCanonicalDecl();
3414 }
3415
3416 /// Return true if this declaration is a completion definition of the type.
3417 /// Provided for consistency.
3418 bool isThisDeclarationADefinition() const {
3419 return isCompleteDefinition();
3420 }
3421
3422 /// Return true if this decl has its body fully specified.
3423 bool isCompleteDefinition() const { return TagDeclBits.IsCompleteDefinition; }
3424
3425 /// True if this decl has its body fully specified.
3426 void setCompleteDefinition(bool V = true) {
3427 TagDeclBits.IsCompleteDefinition = V;
3428 }
3429
3430 /// Return true if this complete decl is
3431 /// required to be complete for some existing use.
3432 bool isCompleteDefinitionRequired() const {
3433 return TagDeclBits.IsCompleteDefinitionRequired;
3434 }
3435
3436 /// True if this complete decl is
3437 /// required to be complete for some existing use.
3438 void setCompleteDefinitionRequired(bool V = true) {
3439 TagDeclBits.IsCompleteDefinitionRequired = V;
3440 }
3441
3442 /// Return true if this decl is currently being defined.
3443 bool isBeingDefined() const { return TagDeclBits.IsBeingDefined; }
3444
3445 /// True if this tag declaration is "embedded" (i.e., defined or declared
3446 /// for the very first time) in the syntax of a declarator.
3447 bool isEmbeddedInDeclarator() const {
3448 return TagDeclBits.IsEmbeddedInDeclarator;
3449 }
3450
3451 /// True if this tag declaration is "embedded" (i.e., defined or declared
3452 /// for the very first time) in the syntax of a declarator.
3453 void setEmbeddedInDeclarator(bool isInDeclarator) {
3454 TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
3455 }
3456
3457 /// True if this tag is free standing, e.g. "struct foo;".
3458 bool isFreeStanding() const { return TagDeclBits.IsFreeStanding; }
3459
3460 /// True if this tag is free standing, e.g. "struct foo;".
3461 void setFreeStanding(bool isFreeStanding = true) {
3462 TagDeclBits.IsFreeStanding = isFreeStanding;
3463 }
3464
3465 /// Indicates whether it is possible for declarations of this kind
3466 /// to have an out-of-date definition.
3467 ///
3468 /// This option is only enabled when modules are enabled.
3469 bool mayHaveOutOfDateDef() const { return TagDeclBits.MayHaveOutOfDateDef; }
3470
3471 /// Whether this declaration declares a type that is
3472 /// dependent, i.e., a type that somehow depends on template
3473 /// parameters.
3474 bool isDependentType() const { return isDependentContext(); }
3475
3476 /// Starts the definition of this tag declaration.
3477 ///
3478 /// This method should be invoked at the beginning of the definition
3479 /// of this tag declaration. It will set the tag type into a state
3480 /// where it is in the process of being defined.
3481 void startDefinition();
3482
3483 /// Returns the TagDecl that actually defines this
3484 /// struct/union/class/enum. When determining whether or not a
3485 /// struct/union/class/enum has a definition, one should use this
3486 /// method as opposed to 'isDefinition'. 'isDefinition' indicates
3487 /// whether or not a specific TagDecl is defining declaration, not
3488 /// whether or not the struct/union/class/enum type is defined.
3489 /// This method returns NULL if there is no TagDecl that defines
3490 /// the struct/union/class/enum.
3491 TagDecl *getDefinition() const;
3492
3493 StringRef getKindName() const {
3494 return TypeWithKeyword::getTagTypeKindName(getTagKind());
3495 }
3496
3497 TagKind getTagKind() const {
3498 return static_cast<TagKind>(TagDeclBits.TagDeclKind);
3499 }
3500
3501 void setTagKind(TagKind TK) { TagDeclBits.TagDeclKind = TK; }
3502
3503 bool isStruct() const { return getTagKind() == TTK_Struct; }
3504 bool isInterface() const { return getTagKind() == TTK_Interface; }
3505 bool isClass() const { return getTagKind() == TTK_Class; }
3506 bool isUnion() const { return getTagKind() == TTK_Union; }
3507 bool isEnum() const { return getTagKind() == TTK_Enum; }
3508
3509 /// Is this tag type named, either directly or via being defined in
3510 /// a typedef of this type?
3511 ///
3512 /// C++11 [basic.link]p8:
3513 /// A type is said to have linkage if and only if:
3514 /// - it is a class or enumeration type that is named (or has a
3515 /// name for linkage purposes) and the name has linkage; ...
3516 /// C++11 [dcl.typedef]p9:
3517 /// If the typedef declaration defines an unnamed class (or enum),
3518 /// the first typedef-name declared by the declaration to be that
3519 /// class type (or enum type) is used to denote the class type (or
3520 /// enum type) for linkage purposes only.
3521 ///
3522 /// C does not have an analogous rule, but the same concept is
3523 /// nonetheless useful in some places.
3524 bool hasNameForLinkage() const {
3525 return (getDeclName() || getTypedefNameForAnonDecl());
3526 }
3527
3528 TypedefNameDecl *getTypedefNameForAnonDecl() const {
3529 return hasExtInfo() ? nullptr
3530 : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
3531 }
3532
3533 void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);
3534
3535 /// Retrieve the nested-name-specifier that qualifies the name of this
3536 /// declaration, if it was present in the source.
3537 NestedNameSpecifier *getQualifier() const {
3538 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
3539 : nullptr;
3540 }
3541
3542 /// Retrieve the nested-name-specifier (with source-location
3543 /// information) that qualifies the name of this declaration, if it was
3544 /// present in the source.
3545 NestedNameSpecifierLoc getQualifierLoc() const {
3546 return hasExtInfo() ? getExtInfo()->QualifierLoc
3547 : NestedNameSpecifierLoc();
3548 }
3549
3550 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
3551
3552 unsigned getNumTemplateParameterLists() const {
3553 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
3554 }
3555
3556 TemplateParameterList *getTemplateParameterList(unsigned i) const {
3557 assert(i < getNumTemplateParameterLists())((void)0);
3558 return getExtInfo()->TemplParamLists[i];
3559 }
3560
3561 void setTemplateParameterListsInfo(ASTContext &Context,
3562 ArrayRef<TemplateParameterList *> TPLists);
3563
3564 // Implement isa/cast/dyncast/etc.
3565 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3566 static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
3567
3568 static DeclContext *castToDeclContext(const TagDecl *D) {
3569 return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
3570 }
3571
3572 static TagDecl *castFromDeclContext(const DeclContext *DC) {
3573 return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
3574 }
3575};
3576
3577/// Represents an enum. In C++11, enums can be forward-declared
3578/// with a fixed underlying type, and in C we allow them to be forward-declared
3579/// with no underlying type as an extension.
3580class EnumDecl : public TagDecl {
3581 // This class stores some data in DeclContext::EnumDeclBits
3582 // to save some space. Use the provided accessors to access it.
3583
3584 /// This represent the integer type that the enum corresponds
3585 /// to for code generation purposes. Note that the enumerator constants may
3586 /// have a different type than this does.
3587 ///
3588 /// If the underlying integer type was explicitly stated in the source
3589 /// code, this is a TypeSourceInfo* for that type. Otherwise this type
3590 /// was automatically deduced somehow, and this is a Type*.
3591 ///
3592 /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
3593 /// some cases it won't.
3594 ///
3595 /// The underlying type of an enumeration never has any qualifiers, so
3596 /// we can get away with just storing a raw Type*, and thus save an
3597 /// extra pointer when TypeSourceInfo is needed.
3598 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3599
3600 /// The integer type that values of this type should
3601 /// promote to. In C, enumerators are generally of an integer type
3602 /// directly, but gcc-style large enumerators (and all enumerators
3603 /// in C++) are of the enum type instead.
3604 QualType PromotionType;
3605
3606 /// If this enumeration is an instantiation of a member enumeration
3607 /// of a class template specialization, this is the member specialization
3608 /// information.
3609 MemberSpecializationInfo *SpecializationInfo = nullptr;
3610
3611 /// Store the ODRHash after first calculation.
3612 /// The corresponding flag HasODRHash is in EnumDeclBits
3613 /// and can be accessed with the provided accessors.
3614 unsigned ODRHash;
3615
3616 EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3617 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
3618 bool Scoped, bool ScopedUsingClassTag, bool Fixed);
3619
3620 void anchor() override;
3621
3622 void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3623 TemplateSpecializationKind TSK);
3624
3625 /// Sets the width in bits required to store all the
3626 /// non-negative enumerators of this enum.
3627 void setNumPositiveBits(unsigned Num) {
3628 EnumDeclBits.NumPositiveBits = Num;
3629 assert(EnumDeclBits.NumPositiveBits == Num && "can't store this bitcount")((void)0);
3630 }
3631
3632 /// Returns the width in bits required to store all the
3633 /// negative enumerators of this enum. (see getNumNegativeBits)
3634 void setNumNegativeBits(unsigned Num) { EnumDeclBits.NumNegativeBits = Num; }
3635
3636public:
3637 /// True if this tag declaration is a scoped enumeration. Only
3638 /// possible in C++11 mode.
3639 void setScoped(bool Scoped = true) { EnumDeclBits.IsScoped = Scoped; }
3640
3641 /// If this tag declaration is a scoped enum,
3642 /// then this is true if the scoped enum was declared using the class
3643 /// tag, false if it was declared with the struct tag. No meaning is
3644 /// associated if this tag declaration is not a scoped enum.
3645 void setScopedUsingClassTag(bool ScopedUCT = true) {
3646 EnumDeclBits.IsScopedUsingClassTag = ScopedUCT;
3647 }
3648
3649 /// True if this is an Objective-C, C++11, or
3650 /// Microsoft-style enumeration with a fixed underlying type.
3651 void setFixed(bool Fixed = true) { EnumDeclBits.IsFixed = Fixed; }
3652
3653private:
3654 /// True if a valid hash is stored in ODRHash.
3655 bool hasODRHash() const { return EnumDeclBits.HasODRHash; }
3656 void setHasODRHash(bool Hash = true) { EnumDeclBits.HasODRHash = Hash; }
3657
3658public:
3659 friend class ASTDeclReader;
3660
3661 EnumDecl *getCanonicalDecl() override {
3662 return cast<EnumDecl>(TagDecl::getCanonicalDecl());
3663 }
3664 const EnumDecl *getCanonicalDecl() const {
3665 return const_cast<EnumDecl*>(this)->getCanonicalDecl();
3666 }
3667
3668 EnumDecl *getPreviousDecl() {
3669 return cast_or_null<EnumDecl>(
3670 static_cast<TagDecl *>(this)->getPreviousDecl());
3671 }
3672 const EnumDecl *getPreviousDecl() const {
3673 return const_cast<EnumDecl*>(this)->getPreviousDecl();
3674 }
3675
3676 EnumDecl *getMostRecentDecl() {
3677 return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3678 }
3679 const EnumDecl *getMostRecentDecl() const {
3680 return const_cast<EnumDecl*>(this)->getMostRecentDecl();
3681 }
3682
3683 EnumDecl *getDefinition() const {
3684 return cast_or_null<EnumDecl>(TagDecl::getDefinition());
3685 }
3686
3687 static EnumDecl *Create(ASTContext &C, DeclContext *DC,
3688 SourceLocation StartLoc, SourceLocation IdLoc,
3689 IdentifierInfo *Id, EnumDecl *PrevDecl,
3690 bool IsScoped, bool IsScopedUsingClassTag,
3691 bool IsFixed);
3692 static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3693
3694 /// When created, the EnumDecl corresponds to a
3695 /// forward-declared enum. This method is used to mark the
3696 /// declaration as being defined; its enumerators have already been
3697 /// added (via DeclContext::addDecl). NewType is the new underlying
3698 /// type of the enumeration type.
3699 void completeDefinition(QualType NewType,
3700 QualType PromotionType,
3701 unsigned NumPositiveBits,
3702 unsigned NumNegativeBits);
3703
3704 // Iterates through the enumerators of this enumeration.
3705 using enumerator_iterator = specific_decl_iterator<EnumConstantDecl>;
3706 using enumerator_range =
3707 llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>;
3708
3709 enumerator_range enumerators() const {
3710 return enumerator_range(enumerator_begin(), enumerator_end());
3711 }
3712
3713 enumerator_iterator enumerator_begin() const {
3714 const EnumDecl *E = getDefinition();
3715 if (!E)
3716 E = this;
3717 return enumerator_iterator(E->decls_begin());
3718 }
3719
3720 enumerator_iterator enumerator_end() const {
3721 const EnumDecl *E = getDefinition();
3722 if (!E)
3723 E = this;
3724 return enumerator_iterator(E->decls_end());
3725 }
3726
3727 /// Return the integer type that enumerators should promote to.
3728 QualType getPromotionType() const { return PromotionType; }
3729
3730 /// Set the promotion type.
3731 void setPromotionType(QualType T) { PromotionType = T; }
3732
3733 /// Return the integer type this enum decl corresponds to.
3734 /// This returns a null QualType for an enum forward definition with no fixed
3735 /// underlying type.
3736 QualType getIntegerType() const {
3737 if (!IntegerType)
3738 return QualType();
3739 if (const Type *T = IntegerType.dyn_cast<const Type*>())
3740 return QualType(T, 0);
3741 return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
3742 }
3743
3744 /// Set the underlying integer type.
3745 void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
3746
3747 /// Set the underlying integer type source info.
3748 void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
3749
3750 /// Return the type source info for the underlying integer type,
3751 /// if no type source info exists, return 0.
3752 TypeSourceInfo *getIntegerTypeSourceInfo() const {
3753 return IntegerType.dyn_cast<TypeSourceInfo*>();
3754 }
3755
3756 /// Retrieve the source range that covers the underlying type if
3757 /// specified.
3758 SourceRange getIntegerTypeRange() const LLVM_READONLY__attribute__((__pure__));
3759
3760 /// Returns the width in bits required to store all the
3761 /// non-negative enumerators of this enum.
3762 unsigned getNumPositiveBits() const { return EnumDeclBits.NumPositiveBits; }
3763
3764 /// Returns the width in bits required to store all the
3765 /// negative enumerators of this enum. These widths include
3766 /// the rightmost leading 1; that is:
3767 ///
3768 /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
3769 /// ------------------------ ------- -----------------
3770 /// -1 1111111 1
3771 /// -10 1110110 5
3772 /// -101 1001011 8
3773 unsigned getNumNegativeBits() const { return EnumDeclBits.NumNegativeBits; }
3774
3775 /// Returns true if this is a C++11 scoped enumeration.
3776 bool isScoped() const { return EnumDeclBits.IsScoped; }
3777
3778 /// Returns true if this is a C++11 scoped enumeration.
3779 bool isScopedUsingClassTag() const {
3780 return EnumDeclBits.IsScopedUsingClassTag;
3781 }
3782
3783 /// Returns true if this is an Objective-C, C++11, or
3784 /// Microsoft-style enumeration with a fixed underlying type.
3785 bool isFixed() const { return EnumDeclBits.IsFixed; }
3786
3787 unsigned getODRHash();
3788
3789 /// Returns true if this can be considered a complete type.
3790 bool isComplete() const {
3791 // IntegerType is set for fixed type enums and non-fixed but implicitly
3792 // int-sized Microsoft enums.
3793 return isCompleteDefinition() || IntegerType;
3794 }
3795
3796 /// Returns true if this enum is either annotated with
3797 /// enum_extensibility(closed) or isn't annotated with enum_extensibility.
3798 bool isClosed() const;
3799
3800 /// Returns true if this enum is annotated with flag_enum and isn't annotated
3801 /// with enum_extensibility(open).
3802 bool isClosedFlag() const;
3803
3804 /// Returns true if this enum is annotated with neither flag_enum nor
3805 /// enum_extensibility(open).
3806 bool isClosedNonFlag() const;
3807
3808 /// Retrieve the enum definition from which this enumeration could
3809 /// be instantiated, if it is an instantiation (rather than a non-template).
3810 EnumDecl *getTemplateInstantiationPattern() const;
3811
3812 /// Returns the enumeration (declared within the template)
3813 /// from which this enumeration type was instantiated, or NULL if
3814 /// this enumeration was not instantiated from any template.
3815 EnumDecl *getInstantiatedFromMemberEnum() const;
3816
3817 /// If this enumeration is a member of a specialization of a
3818 /// templated class, determine what kind of template specialization
3819 /// or instantiation this is.
3820 TemplateSpecializationKind getTemplateSpecializationKind() const;
3821
3822 /// For an enumeration member that was instantiated from a member
3823 /// enumeration of a templated class, set the template specialiation kind.
3824 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3825 SourceLocation PointOfInstantiation = SourceLocation());
3826
3827 /// If this enumeration is an instantiation of a member enumeration of
3828 /// a class template specialization, retrieves the member specialization
3829 /// information.
3830 MemberSpecializationInfo *getMemberSpecializationInfo() const {
3831 return SpecializationInfo;
3832 }
3833
3834 /// Specify that this enumeration is an instantiation of the
3835 /// member enumeration ED.
3836 void setInstantiationOfMemberEnum(EnumDecl *ED,
3837 TemplateSpecializationKind TSK) {
3838 setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3839 }
3840
3841 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3842 static bool classofKind(Kind K) { return K == Enum; }
3843};
3844
3845/// Represents a struct/union/class. For example:
3846/// struct X; // Forward declaration, no "body".
3847/// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3848/// This decl will be marked invalid if *any* members are invalid.
3849class RecordDecl : public TagDecl {
3850 // This class stores some data in DeclContext::RecordDeclBits
3851 // to save some space. Use the provided accessors to access it.
3852public:
3853 friend class DeclContext;
3854 /// Enum that represents the different ways arguments are passed to and
3855 /// returned from function calls. This takes into account the target-specific
3856 /// and version-specific rules along with the rules determined by the
3857 /// language.
3858 enum ArgPassingKind : unsigned {
3859 /// The argument of this type can be passed directly in registers.
3860 APK_CanPassInRegs,
3861
3862 /// The argument of this type cannot be passed directly in registers.
3863 /// Records containing this type as a subobject are not forced to be passed
3864 /// indirectly. This value is used only in C++. This value is required by
3865 /// C++ because, in uncommon situations, it is possible for a class to have
3866 /// only trivial copy/move constructors even when one of its subobjects has
3867 /// a non-trivial copy/move constructor (if e.g. the corresponding copy/move
3868 /// constructor in the derived class is deleted).
3869 APK_CannotPassInRegs,
3870
3871 /// The argument of this type cannot be passed directly in registers.
3872 /// Records containing this type as a subobject are forced to be passed
3873 /// indirectly.
3874 APK_CanNeverPassInRegs
3875 };
3876
3877protected:
3878 RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3879 SourceLocation StartLoc, SourceLocation IdLoc,
3880 IdentifierInfo *Id, RecordDecl *PrevDecl);
3881
3882public:
3883 static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3884 SourceLocation StartLoc, SourceLocation IdLoc,
3885 IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
3886 static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
3887
3888 RecordDecl *getPreviousDecl() {
3889 return cast_or_null<RecordDecl>(
3890 static_cast<TagDecl *>(this)->getPreviousDecl());
3891 }
3892 const RecordDecl *getPreviousDecl() const {
3893 return const_cast<RecordDecl*>(this)->getPreviousDecl();
3894 }
3895
3896 RecordDecl *getMostRecentDecl() {
3897 return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3898 }
3899 const RecordDecl *getMostRecentDecl() const {
3900 return const_cast<RecordDecl*>(this)->getMostRecentDecl();
3901 }
3902
3903 bool hasFlexibleArrayMember() const {
3904 return RecordDeclBits.HasFlexibleArrayMember;
3905 }
3906
3907 void setHasFlexibleArrayMember(bool V) {
3908 RecordDeclBits.HasFlexibleArrayMember = V;
3909 }
3910
3911 /// Whether this is an anonymous struct or union. To be an anonymous
3912 /// struct or union, it must have been declared without a name and
3913 /// there must be no objects of this type declared, e.g.,
3914 /// @code
3915 /// union { int i; float f; };
3916 /// @endcode
3917 /// is an anonymous union but neither of the following are:
3918 /// @code
3919 /// union X { int i; float f; };
3920 /// union { int i; float f; } obj;
3921 /// @endcode
3922 bool isAnonymousStructOrUnion() const {
3923 return RecordDeclBits.AnonymousStructOrUnion;
3924 }
3925
3926 void setAnonymousStructOrUnion(bool Anon) {
3927 RecordDeclBits.AnonymousStructOrUnion = Anon;
3928 }
3929
3930 bool hasObjectMember() const { return RecordDeclBits.HasObjectMember; }
3931 void setHasObjectMember(bool val) { RecordDeclBits.HasObjectMember = val; }
3932
3933 bool hasVolatileMember() const { return RecordDeclBits.HasVolatileMember; }
3934
3935 void setHasVolatileMember(bool val) {
3936 RecordDeclBits.HasVolatileMember = val;
3937 }
3938
3939 bool hasLoadedFieldsFromExternalStorage() const {
3940 return RecordDeclBits.LoadedFieldsFromExternalStorage;
3941 }
3942
3943 void setHasLoadedFieldsFromExternalStorage(bool val) const {
3944 RecordDeclBits.LoadedFieldsFromExternalStorage = val;
3945 }
3946
3947 /// Functions to query basic properties of non-trivial C structs.
3948 bool isNonTrivialToPrimitiveDefaultInitialize() const {
3949 return RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize;
3950 }
3951
3952 void setNonTrivialToPrimitiveDefaultInitialize(bool V) {
3953 RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize = V;
3954 }
3955
3956 bool isNonTrivialToPrimitiveCopy() const {
3957 return RecordDeclBits.NonTrivialToPrimitiveCopy;
3958 }
3959
3960 void setNonTrivialToPrimitiveCopy(bool V) {
3961 RecordDeclBits.NonTrivialToPrimitiveCopy = V;
3962 }
3963
3964 bool isNonTrivialToPrimitiveDestroy() const {
3965 return RecordDeclBits.NonTrivialToPrimitiveDestroy;
3966 }
3967
3968 void setNonTrivialToPrimitiveDestroy(bool V) {
3969 RecordDeclBits.NonTrivialToPrimitiveDestroy = V;
3970 }
3971
3972 bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
3973 return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
3974 }
3975
3976 void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V) {
3977 RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion = V;
3978 }
3979
3980 bool hasNonTrivialToPrimitiveDestructCUnion() const {
3981 return RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion;
3982 }
3983
3984 void setHasNonTrivialToPrimitiveDestructCUnion(bool V) {
3985 RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion = V;
3986 }
3987
3988 bool hasNonTrivialToPrimitiveCopyCUnion() const {
3989 return RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion;
3990 }
3991
3992 void setHasNonTrivialToPrimitiveCopyCUnion(bool V) {
3993 RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion = V;
3994 }
3995
3996 /// Determine whether this class can be passed in registers. In C++ mode,
3997 /// it must have at least one trivial, non-deleted copy or move constructor.
3998 /// FIXME: This should be set as part of completeDefinition.
3999 bool canPassInRegisters() const {
4000 return getArgPassingRestrictions() == APK_CanPassInRegs;
4001 }
4002
4003 ArgPassingKind getArgPassingRestrictions() const {
4004 return static_cast<ArgPassingKind>(RecordDeclBits.ArgPassingRestrictions);
4005 }
4006
4007 void setArgPassingRestrictions(ArgPassingKind Kind) {
4008 RecordDeclBits.ArgPassingRestrictions = Kind;
4009 }
4010
4011 bool isParamDestroyedInCallee() const {
4012 return RecordDeclBits.ParamDestroyedInCallee;
4013 }
4014
4015 void setParamDestroyedInCallee(bool V) {
4016 RecordDeclBits.ParamDestroyedInCallee = V;
4017 }
4018
4019 /// Determines whether this declaration represents the
4020 /// injected class name.
4021 ///
4022 /// The injected class name in C++ is the name of the class that
4023 /// appears inside the class itself. For example:
4024 ///
4025 /// \code
4026 /// struct C {
4027 /// // C is implicitly declared here as a synonym for the class name.
4028 /// };
4029 ///
4030 /// C::C c; // same as "C c;"
4031 /// \endcode
4032 bool isInjectedClassName() const;
4033
4034 /// Determine whether this record is a class describing a lambda
4035 /// function object.
4036 bool isLambda() const;
4037
4038 /// Determine whether this record is a record for captured variables in
4039 /// CapturedStmt construct.
4040 bool isCapturedRecord() const;
4041
4042 /// Mark the record as a record for captured variables in CapturedStmt
4043 /// construct.
4044 void setCapturedRecord();
4045
4046 /// Returns the RecordDecl that actually defines
4047 /// this struct/union/class. When determining whether or not a
4048 /// struct/union/class is completely defined, one should use this
4049 /// method as opposed to 'isCompleteDefinition'.
4050 /// 'isCompleteDefinition' indicates whether or not a specific
4051 /// RecordDecl is a completed definition, not whether or not the
4052 /// record type is defined. This method returns NULL if there is
4053 /// no RecordDecl that defines the struct/union/tag.
4054 RecordDecl *getDefinition() const {
4055 return cast_or_null<RecordDecl>(TagDecl::getDefinition());
4056 }
4057
4058 /// Returns whether this record is a union, or contains (at any nesting level)
4059 /// a union member. This is used by CMSE to warn about possible information
4060 /// leaks.
4061 bool isOrContainsUnion() const;
4062
4063 // Iterator access to field members. The field iterator only visits
4064 // the non-static data members of this class, ignoring any static
4065 // data members, functions, constructors, destructors, etc.
4066 using field_iterator = specific_decl_iterator<FieldDecl>;
4067 using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
4068
4069 field_range fields() const { return field_range(field_begin(), field_end()); }
4070 field_iterator field_begin() const;
4071
4072 field_iterator field_end() const {
4073 return field_iterator(decl_iterator());
4074 }
4075
4076 // Whether there are any fields (non-static data members) in this record.
4077 bool field_empty() const {
4078 return field_begin() == field_end();
16
Calling 'operator=='
22
Returning from 'operator=='
23
Returning the value 1, which participates in a condition later
4079 }
4080
4081 /// Note that the definition of this type is now complete.
4082 virtual void completeDefinition();
4083
4084 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4085 static bool classofKind(Kind K) {
4086 return K >= firstRecord && K <= lastRecord;
4087 }
4088
4089 /// Get whether or not this is an ms_struct which can
4090 /// be turned on with an attribute, pragma, or -mms-bitfields
4091 /// commandline option.
4092 bool isMsStruct(const ASTContext &C) const;
4093
4094 /// Whether we are allowed to insert extra padding between fields.
4095 /// These padding are added to help AddressSanitizer detect
4096 /// intra-object-overflow bugs.
4097 bool mayInsertExtraPadding(bool EmitRemark = false) const;
4098
4099 /// Finds the first data member which has a name.
4100 /// nullptr is returned if no named data member exists.
4101 const FieldDecl *findFirstNamedDataMember() const;
4102
4103private:
4104 /// Deserialize just the fields.
4105 void LoadFieldsFromExternalStorage() const;
4106};
4107
4108class FileScopeAsmDecl : public Decl {
4109 StringLiteral *AsmString;
4110 SourceLocation RParenLoc;
4111
4112 FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
4113 SourceLocation StartL, SourceLocation EndL)
4114 : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
4115
4116 virtual void anchor();
4117
4118public:
4119 static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
4120 StringLiteral *Str, SourceLocation AsmLoc,
4121 SourceLocation RParenLoc);
4122
4123 static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4124
4125 SourceLocation getAsmLoc() const { return getLocation(); }
4126 SourceLocation getRParenLoc() const { return RParenLoc; }
4127 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
4128 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
4129 return SourceRange(getAsmLoc(), getRParenLoc());
4130 }
4131
4132 const StringLiteral *getAsmString() const { return AsmString; }
4133 StringLiteral *getAsmString() { return AsmString; }
4134 void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
4135
4136 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4137 static bool classofKind(Kind K) { return K == FileScopeAsm; }
4138};
4139
4140/// Represents a block literal declaration, which is like an
4141/// unnamed FunctionDecl. For example:
4142/// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
4143class BlockDecl : public Decl, public DeclContext {
4144 // This class stores some data in DeclContext::BlockDeclBits
4145 // to save some space. Use the provided accessors to access it.
4146public:
4147 /// A class which contains all the information about a particular
4148 /// captured value.
4149 class Capture {
4150 enum {
4151 flag_isByRef = 0x1,
4152 flag_isNested = 0x2
4153 };
4154
4155 /// The variable being captured.
4156 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
4157
4158 /// The copy expression, expressed in terms of a DeclRef (or
4159 /// BlockDeclRef) to the captured variable. Only required if the
4160 /// variable has a C++ class type.
4161 Expr *CopyExpr;
4162
4163 public:
4164 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
4165 : VariableAndFlags(variable,
4166 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
4167 CopyExpr(copy) {}
4168
4169 /// The variable being captured.
4170 VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
4171
4172 /// Whether this is a "by ref" capture, i.e. a capture of a __block
4173 /// variable.
4174 bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
4175
4176 bool isEscapingByref() const {
4177 return getVariable()->isEscapingByref();
4178 }
4179
4180 bool isNonEscapingByref() const {
4181 return getVariable()->isNonEscapingByref();
4182 }
4183
4184 /// Whether this is a nested capture, i.e. the variable captured
4185 /// is not from outside the immediately enclosing function/block.
4186 bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
4187
4188 bool hasCopyExpr() const { return CopyExpr != nullptr; }
4189 Expr *getCopyExpr() const { return CopyExpr; }
4190 void setCopyExpr(Expr *e) { CopyExpr = e; }
4191 };
4192
4193private:
4194 /// A new[]'d array of pointers to ParmVarDecls for the formal
4195 /// parameters of this function. This is null if a prototype or if there are
4196 /// no formals.
4197 ParmVarDecl **ParamInfo = nullptr;
4198 unsigned NumParams = 0;
4199
4200 Stmt *Body = nullptr;
4201 TypeSourceInfo *SignatureAsWritten = nullptr;
4202
4203 const Capture *Captures = nullptr;
4204 unsigned NumCaptures = 0;
4205
4206 unsigned ManglingNumber = 0;
4207 Decl *ManglingContextDecl = nullptr;
4208
4209protected:
4210 BlockDecl(DeclContext *DC, SourceLocation CaretLoc);
4211
4212public:
4213 static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
4214 static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4215
4216 SourceLocation getCaretLocation() const { return getLocation(); }
4217
4218 bool isVariadic() const { return BlockDeclBits.IsVariadic; }
4219 void setIsVariadic(bool value) { BlockDeclBits.IsVariadic = value; }
4220
4221 CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
4222 Stmt *getBody() const override { return (Stmt*) Body; }
4223 void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
4224
4225 void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
4226 TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
4227
4228 // ArrayRef access to formal parameters.
4229 ArrayRef<ParmVarDecl *> parameters() const {
4230 return {ParamInfo, getNumParams()};
4231 }
4232 MutableArrayRef<ParmVarDecl *> parameters() {
4233 return {ParamInfo, getNumParams()};
4234 }
4235
4236 // Iterator access to formal parameters.
4237 using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
4238 using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
4239
4240 bool param_empty() const { return parameters().empty(); }
4241 param_iterator param_begin() { return parameters().begin(); }
4242 param_iterator param_end() { return parameters().end(); }
4243 param_const_iterator param_begin() const { return parameters().begin(); }
4244 param_const_iterator param_end() const { return parameters().end(); }
4245 size_t param_size() const { return parameters().size(); }
4246
4247 unsigned getNumParams() const { return NumParams; }
4248
4249 const ParmVarDecl *getParamDecl(unsigned i) const {
4250 assert(i < getNumParams() && "Illegal param #")((void)0);
4251 return ParamInfo[i];
4252 }
4253 ParmVarDecl *getParamDecl(unsigned i) {
4254 assert(i < getNumParams() && "Illegal param #")((void)0);
4255 return ParamInfo[i];
4256 }
4257
4258 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
4259
4260 /// True if this block (or its nested blocks) captures
4261 /// anything of local storage from its enclosing scopes.
4262 bool hasCaptures() const { return NumCaptures || capturesCXXThis(); }
4263
4264 /// Returns the number of captured variables.
4265 /// Does not include an entry for 'this'.
4266 unsigned getNumCaptures() const { return NumCaptures; }
4267
4268 using capture_const_iterator = ArrayRef<Capture>::const_iterator;
4269
4270 ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }
4271
4272 capture_const_iterator capture_begin() const { return captures().begin(); }
4273 capture_const_iterator capture_end() const { return captures().end(); }
4274
4275 bool capturesCXXThis() const { return BlockDeclBits.CapturesCXXThis; }
4276 void setCapturesCXXThis(bool B = true) { BlockDeclBits.CapturesCXXThis = B; }
4277
4278 bool blockMissingReturnType() const {
4279 return BlockDeclBits.BlockMissingReturnType;
4280 }
4281
4282 void setBlockMissingReturnType(bool val = true) {
4283 BlockDeclBits.BlockMissingReturnType = val;
4284 }
4285
4286 bool isConversionFromLambda() const {
4287 return BlockDeclBits.IsConversionFromLambda;
4288 }
4289
4290 void setIsConversionFromLambda(bool val = true) {
4291 BlockDeclBits.IsConversionFromLambda = val;
4292 }
4293
4294 bool doesNotEscape() const { return BlockDeclBits.DoesNotEscape; }
4295 void setDoesNotEscape(bool B = true) { BlockDeclBits.DoesNotEscape = B; }
4296
4297 bool canAvoidCopyToHeap() const {
4298 return BlockDeclBits.CanAvoidCopyToHeap;
4299 }
4300 void setCanAvoidCopyToHeap(bool B = true) {
4301 BlockDeclBits.CanAvoidCopyToHeap = B;
4302 }
4303
4304 bool capturesVariable(const VarDecl *var) const;
4305
4306 void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
4307 bool CapturesCXXThis);
4308
4309 unsigned getBlockManglingNumber() const { return ManglingNumber; }
4310
4311 Decl *getBlockManglingContextDecl() const { return ManglingContextDecl; }
4312
4313 void setBlockMangling(unsigned Number, Decl *Ctx) {
4314 ManglingNumber = Number;
4315 ManglingContextDecl = Ctx;
4316 }
4317
4318 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
4319
4320 // Implement isa/cast/dyncast/etc.
4321 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4322 static bool classofKind(Kind K) { return K == Block; }
4323 static DeclContext *castToDeclContext(const BlockDecl *D) {
4324 return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
4325 }
4326 static BlockDecl *castFromDeclContext(const DeclContext *DC) {
4327 return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
4328 }
4329};
4330
4331/// Represents the body of a CapturedStmt, and serves as its DeclContext.
4332class CapturedDecl final
4333 : public Decl,
4334 public DeclContext,
4335 private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
4336protected:
4337 size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
4338 return NumParams;
4339 }
4340
4341private:
4342 /// The number of parameters to the outlined function.
4343 unsigned NumParams;
4344
4345 /// The position of context parameter in list of parameters.
4346 unsigned ContextParam;
4347
4348 /// The body of the outlined function.
4349 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
4350
4351 explicit CapturedDecl(DeclContext *DC, unsigned NumParams);
4352
4353 ImplicitParamDecl *const *getParams() const {
4354 return getTrailingObjects<ImplicitParamDecl *>();
4355 }
4356
4357 ImplicitParamDecl **getParams() {
4358 return getTrailingObjects<ImplicitParamDecl *>();
4359 }
4360
4361public:
4362 friend class ASTDeclReader;
4363 friend class ASTDeclWriter;
4364 friend TrailingObjects;
4365
4366 static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
4367 unsigned NumParams);
4368 static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4369 unsigned NumParams);
4370
4371 Stmt *getBody() const override;
4372 void setBody(Stmt *B);
4373
4374 bool isNothrow() const;
4375 void setNothrow(bool Nothrow = true);
4376
4377 unsigned getNumParams() const { return NumParams; }
4378
4379 ImplicitParamDecl *getParam(unsigned i) const {
4380 assert(i < NumParams)((void)0);
4381 return getParams()[i];
4382 }
4383 void setParam(unsigned i, ImplicitParamDecl *P) {
4384 assert(i < NumParams)((void)0);
4385 getParams()[i] = P;
4386 }
4387
4388 // ArrayRef interface to parameters.
4389 ArrayRef<ImplicitParamDecl *> parameters() const {
4390 return {getParams(), getNumParams()};
4391 }
4392 MutableArrayRef<ImplicitParamDecl *> parameters() {
4393 return {getParams(), getNumParams()};
4394 }
4395
4396 /// Retrieve the parameter containing captured variables.
4397 ImplicitParamDecl *getContextParam() const {
4398 assert(ContextParam < NumParams)((void)0);
4399 return getParam(ContextParam);
4400 }
4401 void setContextParam(unsigned i, ImplicitParamDecl *P) {
4402 assert(i < NumParams)((void)0);
4403 ContextParam = i;
4404 setParam(i, P);
4405 }
4406 unsigned getContextParamPosition() const { return ContextParam; }
4407
4408 using param_iterator = ImplicitParamDecl *const *;
4409 using param_range = llvm::iterator_range<param_iterator>;
4410
4411 /// Retrieve an iterator pointing to the first parameter decl.
4412 param_iterator param_begin() const { return getParams(); }
4413 /// Retrieve an iterator one past the last parameter decl.
4414 param_iterator param_end() const { return getParams() + NumParams; }
4415
4416 // Implement isa/cast/dyncast/etc.
4417 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4418 static bool classofKind(Kind K) { return K == Captured; }
4419 static DeclContext *castToDeclContext(const CapturedDecl *D) {
4420 return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
4421 }
4422 static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
4423 return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
4424 }
4425};
4426
4427/// Describes a module import declaration, which makes the contents
4428/// of the named module visible in the current translation unit.
4429///
4430/// An import declaration imports the named module (or submodule). For example:
4431/// \code
4432/// @import std.vector;
4433/// \endcode
4434///
4435/// Import declarations can also be implicitly generated from
4436/// \#include/\#import directives.
4437class ImportDecl final : public Decl,
4438 llvm::TrailingObjects<ImportDecl, SourceLocation> {
4439 friend class ASTContext;
4440 friend class ASTDeclReader;
4441 friend class ASTReader;
4442 friend TrailingObjects;
4443
4444 /// The imported module.
4445 Module *ImportedModule = nullptr;
4446
4447 /// The next import in the list of imports local to the translation
4448 /// unit being parsed (not loaded from an AST file).
4449 ///
4450 /// Includes a bit that indicates whether we have source-location information
4451 /// for each identifier in the module name.
4452 ///
4453 /// When the bit is false, we only have a single source location for the
4454 /// end of the import declaration.
4455 llvm::PointerIntPair<ImportDecl *, 1, bool> NextLocalImportAndComplete;
4456
4457 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4458 ArrayRef<SourceLocation> IdentifierLocs);
4459
4460 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4461 SourceLocation EndLoc);
4462
4463 ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}
4464
4465 bool isImportComplete() const { return NextLocalImportAndComplete.getInt(); }
4466
4467 void setImportComplete(bool C) { NextLocalImportAndComplete.setInt(C); }
4468
4469 /// The next import in the list of imports local to the translation
4470 /// unit being parsed (not loaded from an AST file).
4471 ImportDecl *getNextLocalImport() const {
4472 return NextLocalImportAndComplete.getPointer();
4473 }
4474
4475 void setNextLocalImport(ImportDecl *Import) {
4476 NextLocalImportAndComplete.setPointer(Import);
4477 }
4478
4479public:
4480 /// Create a new module import declaration.
4481 static ImportDecl *Create(ASTContext &C, DeclContext *DC,
4482 SourceLocation StartLoc, Module *Imported,
4483 ArrayRef<SourceLocation> IdentifierLocs);
4484
4485 /// Create a new module import declaration for an implicitly-generated
4486 /// import.
4487 static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
4488 SourceLocation StartLoc, Module *Imported,
4489 SourceLocation EndLoc);
4490
4491 /// Create a new, deserialized module import declaration.
4492 static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4493 unsigned NumLocations);
4494
4495 /// Retrieve the module that was imported by the import declaration.
4496 Module *getImportedModule() const { return ImportedModule; }
4497
4498 /// Retrieves the locations of each of the identifiers that make up
4499 /// the complete module name in the import declaration.
4500 ///
4501 /// This will return an empty array if the locations of the individual
4502 /// identifiers aren't available.
4503 ArrayRef<SourceLocation> getIdentifierLocs() const;
4504
4505 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
4506
4507 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4508 static bool classofKind(Kind K) { return K == Import; }
4509};
4510
4511/// Represents a C++ Modules TS module export declaration.
4512///
4513/// For example:
4514/// \code
4515/// export void foo();
4516/// \endcode
4517class ExportDecl final : public Decl, public DeclContext {
4518 virtual void anchor();
4519
4520private:
4521 friend class ASTDeclReader;
4522
4523 /// The source location for the right brace (if valid).
4524 SourceLocation RBraceLoc;
4525
4526 ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
4527 : Decl(Export, DC, ExportLoc), DeclContext(Export),
4528 RBraceLoc(SourceLocation()) {}
4529
4530public:
4531 static ExportDecl *Create(ASTContext &C, DeclContext *DC,
4532 SourceLocation ExportLoc);
4533 static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4534
4535 SourceLocation getExportLoc() const { return getLocation(); }
4536 SourceLocation getRBraceLoc() const { return RBraceLoc; }
4537 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
4538
4539 bool hasBraces() const { return RBraceLoc.isValid(); }
4540
4541 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
4542 if (hasBraces())
4543 return RBraceLoc;
4544 // No braces: get the end location of the (only) declaration in context
4545 // (if present).
4546 return decls_empty() ? getLocation() : decls_begin()->getEndLoc();
4547 }
4548
4549 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
4550 return SourceRange(getLocation(), getEndLoc());
4551 }
4552
4553 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4554 static bool classofKind(Kind K) { return K == Export; }
4555 static DeclContext *castToDeclContext(const ExportDecl *D) {
4556 return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
4557 }
4558 static ExportDecl *castFromDeclContext(const DeclContext *DC) {
4559 return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
4560 }
4561};
4562
4563/// Represents an empty-declaration.
4564class EmptyDecl : public Decl {
4565 EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}
4566
4567 virtual void anchor();
4568
4569public:
4570 static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
4571 SourceLocation L);
4572 static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4573
4574 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4575 static bool classofKind(Kind K) { return K == Empty; }
4576};
4577
4578/// Insertion operator for diagnostics. This allows sending NamedDecl's
4579/// into a diagnostic with <<.
4580inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
4581 const NamedDecl *ND) {
4582 PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
4583 DiagnosticsEngine::ak_nameddecl);
4584 return PD;
4585}
4586
4587template<typename decl_type>
4588void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
4589 // Note: This routine is implemented here because we need both NamedDecl
4590 // and Redeclarable to be defined.
4591 assert(RedeclLink.isFirst() &&((void)0)
4592 "setPreviousDecl on a decl already in a redeclaration chain")((void)0);
4593
4594 if (PrevDecl) {
4595 // Point to previous. Make sure that this is actually the most recent
4596 // redeclaration, or we can build invalid chains. If the most recent
4597 // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
4598 First = PrevDecl->getFirstDecl();
4599 assert(First->RedeclLink.isFirst() && "Expected first")((void)0);
4600 decl_type *MostRecent = First->getNextRedeclaration();
4601 RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
4602
4603 // If the declaration was previously visible, a redeclaration of it remains
4604 // visible even if it wouldn't be visible by itself.
4605 static_cast<decl_type*>(this)->IdentifierNamespace |=
4606 MostRecent->getIdentifierNamespace() &
4607 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
4608 } else {
4609 // Make this first.
4610 First = static_cast<decl_type*>(this);
4611 }
4612
4613 // First one will point to this one as latest.
4614 First->RedeclLink.setLatest(static_cast<decl_type*>(this));
4615
4616 assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||((void)0)
4617 cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid())((void)0);
4618}
4619
4620// Inline function definitions.
4621
4622/// Check if the given decl is complete.
4623///
4624/// We use this function to break a cycle between the inline definitions in
4625/// Type.h and Decl.h.
4626inline bool IsEnumDeclComplete(EnumDecl *ED) {
4627 return ED->isComplete();
4628}
4629
4630/// Check if the given decl is scoped.
4631///
4632/// We use this function to break a cycle between the inline definitions in
4633/// Type.h and Decl.h.
4634inline bool IsEnumDeclScoped(EnumDecl *ED) {
4635 return ED->isScoped();
4636}
4637
4638/// OpenMP variants are mangled early based on their OpenMP context selector.
4639/// The new name looks likes this:
4640/// <name> + OpenMPVariantManglingSeparatorStr + <mangled OpenMP context>
4641static constexpr StringRef getOpenMPVariantManglingSeparatorStr() {
4642 return "$ompvariant";
4643}
4644
4645} // namespace clang
4646
4647#endif // LLVM_CLANG_AST_DECL_H

/usr/src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/clang/include/clang/AST/DeclBase.h

1//===- DeclBase.h - Base Classes for representing declarations --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the Decl and DeclContext interfaces.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_DECLBASE_H
14#define LLVM_CLANG_AST_DECLBASE_H
15
16#include "clang/AST/ASTDumperUtils.h"
17#include "clang/AST/AttrIterator.h"
18#include "clang/AST/DeclarationName.h"
19#include "clang/Basic/IdentifierTable.h"
20#include "clang/Basic/LLVM.h"
21#include "clang/Basic/SourceLocation.h"
22#include "clang/Basic/Specifiers.h"
23#include "llvm/ADT/ArrayRef.h"
24#include "llvm/ADT/PointerIntPair.h"
25#include "llvm/ADT/PointerUnion.h"
26#include "llvm/ADT/iterator.h"
27#include "llvm/ADT/iterator_range.h"
28#include "llvm/Support/Casting.h"
29#include "llvm/Support/Compiler.h"
30#include "llvm/Support/PrettyStackTrace.h"
31#include "llvm/Support/VersionTuple.h"
32#include <algorithm>
33#include <cassert>
34#include <cstddef>
35#include <iterator>
36#include <string>
37#include <type_traits>
38#include <utility>
39
40namespace clang {
41
42class ASTContext;
43class ASTMutationListener;
44class Attr;
45class BlockDecl;
46class DeclContext;
47class ExternalSourceSymbolAttr;
48class FunctionDecl;
49class FunctionType;
50class IdentifierInfo;
51enum Linkage : unsigned char;
52class LinkageSpecDecl;
53class Module;
54class NamedDecl;
55class ObjCCategoryDecl;
56class ObjCCategoryImplDecl;
57class ObjCContainerDecl;
58class ObjCImplDecl;
59class ObjCImplementationDecl;
60class ObjCInterfaceDecl;
61class ObjCMethodDecl;
62class ObjCProtocolDecl;
63struct PrintingPolicy;
64class RecordDecl;
65class SourceManager;
66class Stmt;
67class StoredDeclsMap;
68class TemplateDecl;
69class TemplateParameterList;
70class TranslationUnitDecl;
71class UsingDirectiveDecl;
72
73/// Captures the result of checking the availability of a
74/// declaration.
75enum AvailabilityResult {
76 AR_Available = 0,
77 AR_NotYetIntroduced,
78 AR_Deprecated,
79 AR_Unavailable
80};
81
82/// Decl - This represents one declaration (or definition), e.g. a variable,
83/// typedef, function, struct, etc.
84///
85/// Note: There are objects tacked on before the *beginning* of Decl
86/// (and its subclasses) in its Decl::operator new(). Proper alignment
87/// of all subclasses (not requiring more than the alignment of Decl) is
88/// asserted in DeclBase.cpp.
89class alignas(8) Decl {
90public:
91 /// Lists the kind of concrete classes of Decl.
92 enum Kind {
93#define DECL(DERIVED, BASE) DERIVED,
94#define ABSTRACT_DECL(DECL)
95#define DECL_RANGE(BASE, START, END) \
96 first##BASE = START, last##BASE = END,
97#define LAST_DECL_RANGE(BASE, START, END) \
98 first##BASE = START, last##BASE = END
99#include "clang/AST/DeclNodes.inc"
100 };
101
102 /// A placeholder type used to construct an empty shell of a
103 /// decl-derived type that will be filled in later (e.g., by some
104 /// deserialization method).
105 struct EmptyShell {};
106
107 /// IdentifierNamespace - The different namespaces in which
108 /// declarations may appear. According to C99 6.2.3, there are
109 /// four namespaces, labels, tags, members and ordinary
110 /// identifiers. C++ describes lookup completely differently:
111 /// certain lookups merely "ignore" certain kinds of declarations,
112 /// usually based on whether the declaration is of a type, etc.
113 ///
114 /// These are meant as bitmasks, so that searches in
115 /// C++ can look into the "tag" namespace during ordinary lookup.
116 ///
117 /// Decl currently provides 15 bits of IDNS bits.
118 enum IdentifierNamespace {
119 /// Labels, declared with 'x:' and referenced with 'goto x'.
120 IDNS_Label = 0x0001,
121
122 /// Tags, declared with 'struct foo;' and referenced with
123 /// 'struct foo'. All tags are also types. This is what
124 /// elaborated-type-specifiers look for in C.
125 /// This also contains names that conflict with tags in the
126 /// same scope but that are otherwise ordinary names (non-type
127 /// template parameters and indirect field declarations).
128 IDNS_Tag = 0x0002,
129
130 /// Types, declared with 'struct foo', typedefs, etc.
131 /// This is what elaborated-type-specifiers look for in C++,
132 /// but note that it's ill-formed to find a non-tag.
133 IDNS_Type = 0x0004,
134
135 /// Members, declared with object declarations within tag
136 /// definitions. In C, these can only be found by "qualified"
137 /// lookup in member expressions. In C++, they're found by
138 /// normal lookup.
139 IDNS_Member = 0x0008,
140
141 /// Namespaces, declared with 'namespace foo {}'.
142 /// Lookup for nested-name-specifiers find these.
143 IDNS_Namespace = 0x0010,
144
145 /// Ordinary names. In C, everything that's not a label, tag,
146 /// member, or function-local extern ends up here.
147 IDNS_Ordinary = 0x0020,
148
149 /// Objective C \@protocol.
150 IDNS_ObjCProtocol = 0x0040,
151
152 /// This declaration is a friend function. A friend function
153 /// declaration is always in this namespace but may also be in
154 /// IDNS_Ordinary if it was previously declared.
155 IDNS_OrdinaryFriend = 0x0080,
156
157 /// This declaration is a friend class. A friend class
158 /// declaration is always in this namespace but may also be in
159 /// IDNS_Tag|IDNS_Type if it was previously declared.
160 IDNS_TagFriend = 0x0100,
161
162 /// This declaration is a using declaration. A using declaration
163 /// *introduces* a number of other declarations into the current
164 /// scope, and those declarations use the IDNS of their targets,
165 /// but the actual using declarations go in this namespace.
166 IDNS_Using = 0x0200,
167
168 /// This declaration is a C++ operator declared in a non-class
169 /// context. All such operators are also in IDNS_Ordinary.
170 /// C++ lexical operator lookup looks for these.
171 IDNS_NonMemberOperator = 0x0400,
172
173 /// This declaration is a function-local extern declaration of a
174 /// variable or function. This may also be IDNS_Ordinary if it
175 /// has been declared outside any function. These act mostly like
176 /// invisible friend declarations, but are also visible to unqualified
177 /// lookup within the scope of the declaring function.
178 IDNS_LocalExtern = 0x0800,
179
180 /// This declaration is an OpenMP user defined reduction construction.
181 IDNS_OMPReduction = 0x1000,
182
183 /// This declaration is an OpenMP user defined mapper.
184 IDNS_OMPMapper = 0x2000,
185 };
186
187 /// ObjCDeclQualifier - 'Qualifiers' written next to the return and
188 /// parameter types in method declarations. Other than remembering
189 /// them and mangling them into the method's signature string, these
190 /// are ignored by the compiler; they are consumed by certain
191 /// remote-messaging frameworks.
192 ///
193 /// in, inout, and out are mutually exclusive and apply only to
194 /// method parameters. bycopy and byref are mutually exclusive and
195 /// apply only to method parameters (?). oneway applies only to
196 /// results. All of these expect their corresponding parameter to
197 /// have a particular type. None of this is currently enforced by
198 /// clang.
199 ///
200 /// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
201 enum ObjCDeclQualifier {
202 OBJC_TQ_None = 0x0,
203 OBJC_TQ_In = 0x1,
204 OBJC_TQ_Inout = 0x2,
205 OBJC_TQ_Out = 0x4,
206 OBJC_TQ_Bycopy = 0x8,
207 OBJC_TQ_Byref = 0x10,
208 OBJC_TQ_Oneway = 0x20,
209
210 /// The nullability qualifier is set when the nullability of the
211 /// result or parameter was expressed via a context-sensitive
212 /// keyword.
213 OBJC_TQ_CSNullability = 0x40
214 };
215
216 /// The kind of ownership a declaration has, for visibility purposes.
217 /// This enumeration is designed such that higher values represent higher
218 /// levels of name hiding.
219 enum class ModuleOwnershipKind : unsigned {
220 /// This declaration is not owned by a module.
221 Unowned,
222
223 /// This declaration has an owning module, but is globally visible
224 /// (typically because its owning module is visible and we know that
225 /// modules cannot later become hidden in this compilation).
226 /// After serialization and deserialization, this will be converted
227 /// to VisibleWhenImported.
228 Visible,
229
230 /// This declaration has an owning module, and is visible when that
231 /// module is imported.
232 VisibleWhenImported,
233
234 /// This declaration has an owning module, but is only visible to
235 /// lookups that occur within that module.
236 ModulePrivate
237 };
238
239protected:
240 /// The next declaration within the same lexical
241 /// DeclContext. These pointers form the linked list that is
242 /// traversed via DeclContext's decls_begin()/decls_end().
243 ///
244 /// The extra two bits are used for the ModuleOwnershipKind.
245 llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;
246
247private:
248 friend class DeclContext;
249
250 struct MultipleDC {
251 DeclContext *SemanticDC;
252 DeclContext *LexicalDC;
253 };
254
255 /// DeclCtx - Holds either a DeclContext* or a MultipleDC*.
256 /// For declarations that don't contain C++ scope specifiers, it contains
257 /// the DeclContext where the Decl was declared.
258 /// For declarations with C++ scope specifiers, it contains a MultipleDC*
259 /// with the context where it semantically belongs (SemanticDC) and the
260 /// context where it was lexically declared (LexicalDC).
261 /// e.g.:
262 ///
263 /// namespace A {
264 /// void f(); // SemanticDC == LexicalDC == 'namespace A'
265 /// }
266 /// void A::f(); // SemanticDC == namespace 'A'
267 /// // LexicalDC == global namespace
268 llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx;
269
270 bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }
271 bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }
272
273 MultipleDC *getMultipleDC() const {
274 return DeclCtx.get<MultipleDC*>();
275 }
276
277 DeclContext *getSemanticDC() const {
278 return DeclCtx.get<DeclContext*>();
279 }
280
281 /// Loc - The location of this decl.
282 SourceLocation Loc;
283
284 /// DeclKind - This indicates which class this is.
285 unsigned DeclKind : 7;
286
287 /// InvalidDecl - This indicates a semantic error occurred.
288 unsigned InvalidDecl : 1;
289
290 /// HasAttrs - This indicates whether the decl has attributes or not.
291 unsigned HasAttrs : 1;
292
293 /// Implicit - Whether this declaration was implicitly generated by
294 /// the implementation rather than explicitly written by the user.
295 unsigned Implicit : 1;
296
297 /// Whether this declaration was "used", meaning that a definition is
298 /// required.
299 unsigned Used : 1;
300
301 /// Whether this declaration was "referenced".
302 /// The difference with 'Used' is whether the reference appears in a
303 /// evaluated context or not, e.g. functions used in uninstantiated templates
304 /// are regarded as "referenced" but not "used".
305 unsigned Referenced : 1;
306
307 /// Whether this declaration is a top-level declaration (function,
308 /// global variable, etc.) that is lexically inside an objc container
309 /// definition.
310 unsigned TopLevelDeclInObjCContainer : 1;
311
312 /// Whether statistic collection is enabled.
313 static bool StatisticsEnabled;
314
315protected:
316 friend class ASTDeclReader;
317 friend class ASTDeclWriter;
318 friend class ASTNodeImporter;
319 friend class ASTReader;
320 friend class CXXClassMemberWrapper;
321 friend class LinkageComputer;
322 template<typename decl_type> friend class Redeclarable;
323
324 /// Access - Used by C++ decls for the access specifier.
325 // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum
326 unsigned Access : 2;
327
328 /// Whether this declaration was loaded from an AST file.
329 unsigned FromASTFile : 1;
330
331 /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
332 unsigned IdentifierNamespace : 14;
333
334 /// If 0, we have not computed the linkage of this declaration.
335 /// Otherwise, it is the linkage + 1.
336 mutable unsigned CacheValidAndLinkage : 3;
337
338 /// Allocate memory for a deserialized declaration.
339 ///
340 /// This routine must be used to allocate memory for any declaration that is
341 /// deserialized from a module file.
342 ///
343 /// \param Size The size of the allocated object.
344 /// \param Ctx The context in which we will allocate memory.
345 /// \param ID The global ID of the deserialized declaration.
346 /// \param Extra The amount of extra space to allocate after the object.
347 void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,
348 std::size_t Extra = 0);
349
350 /// Allocate memory for a non-deserialized declaration.
351 void *operator new(std::size_t Size, const ASTContext &Ctx,
352 DeclContext *Parent, std::size_t Extra = 0);
353
354private:
355 bool AccessDeclContextSanity() const;
356
357 /// Get the module ownership kind to use for a local lexical child of \p DC,
358 /// which may be either a local or (rarely) an imported declaration.
359 static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {
360 if (DC) {
361 auto *D = cast<Decl>(DC);
362 auto MOK = D->getModuleOwnershipKind();
363 if (MOK != ModuleOwnershipKind::Unowned &&
364 (!D->isFromASTFile() || D->hasLocalOwningModuleStorage()))
365 return MOK;
366 // If D is not local and we have no local module storage, then we don't
367 // need to track module ownership at all.
368 }
369 return ModuleOwnershipKind::Unowned;
370 }
371
372public:
373 Decl() = delete;
374 Decl(const Decl&) = delete;
375 Decl(Decl &&) = delete;
376 Decl &operator=(const Decl&) = delete;
377 Decl &operator=(Decl&&) = delete;
378
379protected:
380 Decl(Kind DK, DeclContext *DC, SourceLocation L)
381 : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),
382 DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),
383 Implicit(false), Used(false), Referenced(false),
384 TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),
385 IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
386 CacheValidAndLinkage(0) {
387 if (StatisticsEnabled) add(DK);
388 }
389
390 Decl(Kind DK, EmptyShell Empty)
391 : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
392 Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
393 Access(AS_none), FromASTFile(0),
394 IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
395 CacheValidAndLinkage(0) {
396 if (StatisticsEnabled) add(DK);
397 }
398
399 virtual ~Decl();
400
401 /// Update a potentially out-of-date declaration.
402 void updateOutOfDate(IdentifierInfo &II) const;
403
404 Linkage getCachedLinkage() const {
405 return Linkage(CacheValidAndLinkage - 1);
406 }
407
408 void setCachedLinkage(Linkage L) const {
409 CacheValidAndLinkage = L + 1;
410 }
411
412 bool hasCachedLinkage() const {
413 return CacheValidAndLinkage;
414 }
415
416public:
417 /// Source range that this declaration covers.
418 virtual SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
419 return SourceRange(getLocation(), getLocation());
420 }
421
422 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
423 return getSourceRange().getBegin();
424 }
425
426 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
427 return getSourceRange().getEnd();
428 }
429
430 SourceLocation getLocation() const { return Loc; }
431 void setLocation(SourceLocation L) { Loc = L; }
432
433 Kind getKind() const { return static_cast<Kind>(DeclKind); }
434 const char *getDeclKindName() const;
435
436 Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }
437 const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}
438
439 DeclContext *getDeclContext() {
440 if (isInSemaDC())
441 return getSemanticDC();
442 return getMultipleDC()->SemanticDC;
443 }
444 const DeclContext *getDeclContext() const {
445 return const_cast<Decl*>(this)->getDeclContext();
446 }
447
448 /// Find the innermost non-closure ancestor of this declaration,
449 /// walking up through blocks, lambdas, etc. If that ancestor is
450 /// not a code context (!isFunctionOrMethod()), returns null.
451 ///
452 /// A declaration may be its own non-closure context.
453 Decl *getNonClosureContext();
454 const Decl *getNonClosureContext() const {
455 return const_cast<Decl*>(this)->getNonClosureContext();
456 }
457
458 TranslationUnitDecl *getTranslationUnitDecl();
459 const TranslationUnitDecl *getTranslationUnitDecl() const {
460 return const_cast<Decl*>(this)->getTranslationUnitDecl();
461 }
462
463 bool isInAnonymousNamespace() const;
464
465 bool isInStdNamespace() const;
466
467 ASTContext &getASTContext() const LLVM_READONLY__attribute__((__pure__));
468
469 /// Helper to get the language options from the ASTContext.
470 /// Defined out of line to avoid depending on ASTContext.h.
471 const LangOptions &getLangOpts() const LLVM_READONLY__attribute__((__pure__));
472
473 void setAccess(AccessSpecifier AS) {
474 Access = AS;
475 assert(AccessDeclContextSanity())((void)0);
476 }
477
478 AccessSpecifier getAccess() const {
479 assert(AccessDeclContextSanity())((void)0);
480 return AccessSpecifier(Access);
481 }
482
483 /// Retrieve the access specifier for this declaration, even though
484 /// it may not yet have been properly set.
485 AccessSpecifier getAccessUnsafe() const {
486 return AccessSpecifier(Access);
487 }
488
489 bool hasAttrs() const { return HasAttrs; }
490
491 void setAttrs(const AttrVec& Attrs) {
492 return setAttrsImpl(Attrs, getASTContext());
493 }
494
495 AttrVec &getAttrs() {
496 return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());
497 }
498
499 const AttrVec &getAttrs() const;
500 void dropAttrs();
501 void addAttr(Attr *A);
502
503 using attr_iterator = AttrVec::const_iterator;
504 using attr_range = llvm::iterator_range<attr_iterator>;
505
506 attr_range attrs() const {
507 return attr_range(attr_begin(), attr_end());
508 }
509
510 attr_iterator attr_begin() const {
511 return hasAttrs() ? getAttrs().begin() : nullptr;
512 }
513 attr_iterator attr_end() const {
514 return hasAttrs() ? getAttrs().end() : nullptr;
515 }
516
517 template <typename T>
518 void dropAttr() {
519 if (!HasAttrs) return;
520
521 AttrVec &Vec = getAttrs();
522 llvm::erase_if(Vec, [](Attr *A) { return isa<T>(A); });
523
524 if (Vec.empty())
525 HasAttrs = false;
526 }
527
528 template <typename T>
529 llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
530 return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
531 }
532
533 template <typename T>
534 specific_attr_iterator<T> specific_attr_begin() const {
535 return specific_attr_iterator<T>(attr_begin());
536 }
537
538 template <typename T>
539 specific_attr_iterator<T> specific_attr_end() const {
540 return specific_attr_iterator<T>(attr_end());
541 }
542
543 template<typename T> T *getAttr() const {
544 return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
545 }
546
547 template<typename T> bool hasAttr() const {
548 return hasAttrs() && hasSpecificAttr<T>(getAttrs());
549 }
550
551 /// getMaxAlignment - return the maximum alignment specified by attributes
552 /// on this decl, 0 if there are none.
553 unsigned getMaxAlignment() const;
554
555 /// setInvalidDecl - Indicates the Decl had a semantic error. This
556 /// allows for graceful error recovery.
557 void setInvalidDecl(bool Invalid = true);
558 bool isInvalidDecl() const { return (bool) InvalidDecl; }
559
560 /// isImplicit - Indicates whether the declaration was implicitly
561 /// generated by the implementation. If false, this declaration
562 /// was written explicitly in the source code.
563 bool isImplicit() const { return Implicit; }
564 void setImplicit(bool I = true) { Implicit = I; }
565
566 /// Whether *any* (re-)declaration of the entity was used, meaning that
567 /// a definition is required.
568 ///
569 /// \param CheckUsedAttr When true, also consider the "used" attribute
570 /// (in addition to the "used" bit set by \c setUsed()) when determining
571 /// whether the function is used.
572 bool isUsed(bool CheckUsedAttr = true) const;
573
574 /// Set whether the declaration is used, in the sense of odr-use.
575 ///
576 /// This should only be used immediately after creating a declaration.
577 /// It intentionally doesn't notify any listeners.
578 void setIsUsed() { getCanonicalDecl()->Used = true; }
579
580 /// Mark the declaration used, in the sense of odr-use.
581 ///
582 /// This notifies any mutation listeners in addition to setting a bit
583 /// indicating the declaration is used.
584 void markUsed(ASTContext &C);
585
586 /// Whether any declaration of this entity was referenced.
587 bool isReferenced() const;
588
589 /// Whether this declaration was referenced. This should not be relied
590 /// upon for anything other than debugging.
591 bool isThisDeclarationReferenced() const { return Referenced; }
592
593 void setReferenced(bool R = true) { Referenced = R; }
594
595 /// Whether this declaration is a top-level declaration (function,
596 /// global variable, etc.) that is lexically inside an objc container
597 /// definition.
598 bool isTopLevelDeclInObjCContainer() const {
599 return TopLevelDeclInObjCContainer;
600 }
601
602 void setTopLevelDeclInObjCContainer(bool V = true) {
603 TopLevelDeclInObjCContainer = V;
604 }
605
606 /// Looks on this and related declarations for an applicable
607 /// external source symbol attribute.
608 ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;
609
610 /// Whether this declaration was marked as being private to the
611 /// module in which it was defined.
612 bool isModulePrivate() const {
613 return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate;
614 }
615
616 /// Return true if this declaration has an attribute which acts as
617 /// definition of the entity, such as 'alias' or 'ifunc'.
618 bool hasDefiningAttr() const;
619
620 /// Return this declaration's defining attribute if it has one.
621 const Attr *getDefiningAttr() const;
622
623protected:
624 /// Specify that this declaration was marked as being private
625 /// to the module in which it was defined.
626 void setModulePrivate() {
627 // The module-private specifier has no effect on unowned declarations.
628 // FIXME: We should track this in some way for source fidelity.
629 if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)
630 return;
631 setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);
632 }
633
634public:
635 /// Set the FromASTFile flag. This indicates that this declaration
636 /// was deserialized and not parsed from source code and enables
637 /// features such as module ownership information.
638 void setFromASTFile() {
639 FromASTFile = true;
640 }
641
642 /// Set the owning module ID. This may only be called for
643 /// deserialized Decls.
644 void setOwningModuleID(unsigned ID) {
645 assert(isFromASTFile() && "Only works on a deserialized declaration")((void)0);
646 *((unsigned*)this - 2) = ID;
647 }
648
649public:
650 /// Determine the availability of the given declaration.
651 ///
652 /// This routine will determine the most restrictive availability of
653 /// the given declaration (e.g., preferring 'unavailable' to
654 /// 'deprecated').
655 ///
656 /// \param Message If non-NULL and the result is not \c
657 /// AR_Available, will be set to a (possibly empty) message
658 /// describing why the declaration has not been introduced, is
659 /// deprecated, or is unavailable.
660 ///
661 /// \param EnclosingVersion The version to compare with. If empty, assume the
662 /// deployment target version.
663 ///
664 /// \param RealizedPlatform If non-NULL and the availability result is found
665 /// in an available attribute it will set to the platform which is written in
666 /// the available attribute.
667 AvailabilityResult
668 getAvailability(std::string *Message = nullptr,
669 VersionTuple EnclosingVersion = VersionTuple(),
670 StringRef *RealizedPlatform = nullptr) const;
671
672 /// Retrieve the version of the target platform in which this
673 /// declaration was introduced.
674 ///
675 /// \returns An empty version tuple if this declaration has no 'introduced'
676 /// availability attributes, or the version tuple that's specified in the
677 /// attribute otherwise.
678 VersionTuple getVersionIntroduced() const;
679
680 /// Determine whether this declaration is marked 'deprecated'.
681 ///
682 /// \param Message If non-NULL and the declaration is deprecated,
683 /// this will be set to the message describing why the declaration
684 /// was deprecated (which may be empty).
685 bool isDeprecated(std::string *Message = nullptr) const {
686 return getAvailability(Message) == AR_Deprecated;
687 }
688
689 /// Determine whether this declaration is marked 'unavailable'.
690 ///
691 /// \param Message If non-NULL and the declaration is unavailable,
692 /// this will be set to the message describing why the declaration
693 /// was made unavailable (which may be empty).
694 bool isUnavailable(std::string *Message = nullptr) const {
695 return getAvailability(Message) == AR_Unavailable;
696 }
697
698 /// Determine whether this is a weak-imported symbol.
699 ///
700 /// Weak-imported symbols are typically marked with the
701 /// 'weak_import' attribute, but may also be marked with an
702 /// 'availability' attribute where we're targing a platform prior to
703 /// the introduction of this feature.
704 bool isWeakImported() const;
705
706 /// Determines whether this symbol can be weak-imported,
707 /// e.g., whether it would be well-formed to add the weak_import
708 /// attribute.
709 ///
710 /// \param IsDefinition Set to \c true to indicate that this
711 /// declaration cannot be weak-imported because it has a definition.
712 bool canBeWeakImported(bool &IsDefinition) const;
713
714 /// Determine whether this declaration came from an AST file (such as
715 /// a precompiled header or module) rather than having been parsed.
716 bool isFromASTFile() const { return FromASTFile; }
717
718 /// Retrieve the global declaration ID associated with this
719 /// declaration, which specifies where this Decl was loaded from.
720 unsigned getGlobalID() const {
721 if (isFromASTFile())
722 return *((const unsigned*)this - 1);
723 return 0;
724 }
725
726 /// Retrieve the global ID of the module that owns this particular
727 /// declaration.
728 unsigned getOwningModuleID() const {
729 if (isFromASTFile())
730 return *((const unsigned*)this - 2);
731 return 0;
732 }
733
734private:
735 Module *getOwningModuleSlow() const;
736
737protected:
738 bool hasLocalOwningModuleStorage() const;
739
740public:
741 /// Get the imported owning module, if this decl is from an imported
742 /// (non-local) module.
743 Module *getImportedOwningModule() const {
744 if (!isFromASTFile() || !hasOwningModule())
745 return nullptr;
746
747 return getOwningModuleSlow();
748 }
749
750 /// Get the local owning module, if known. Returns nullptr if owner is
751 /// not yet known or declaration is not from a module.
752 Module *getLocalOwningModule() const {
753 if (isFromASTFile() || !hasOwningModule())
754 return nullptr;
755
756 assert(hasLocalOwningModuleStorage() &&((void)0)
757 "owned local decl but no local module storage")((void)0);
758 return reinterpret_cast<Module *const *>(this)[-1];
759 }
760 void setLocalOwningModule(Module *M) {
761 assert(!isFromASTFile() && hasOwningModule() &&((void)0)
762 hasLocalOwningModuleStorage() &&((void)0)
763 "should not have a cached owning module")((void)0);
764 reinterpret_cast<Module **>(this)[-1] = M;
765 }
766
767 /// Is this declaration owned by some module?
768 bool hasOwningModule() const {
769 return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;
770 }
771
772 /// Get the module that owns this declaration (for visibility purposes).
773 Module *getOwningModule() const {
774 return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();
775 }
776
777 /// Get the module that owns this declaration for linkage purposes.
778 /// There only ever is such a module under the C++ Modules TS.
779 ///
780 /// \param IgnoreLinkage Ignore the linkage of the entity; assume that
781 /// all declarations in a global module fragment are unowned.
782 Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;
783
784 /// Determine whether this declaration is definitely visible to name lookup,
785 /// independent of whether the owning module is visible.
786 /// Note: The declaration may be visible even if this returns \c false if the
787 /// owning module is visible within the query context. This is a low-level
788 /// helper function; most code should be calling Sema::isVisible() instead.
789 bool isUnconditionallyVisible() const {
790 return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;
791 }
792
793 /// Set that this declaration is globally visible, even if it came from a
794 /// module that is not visible.
795 void setVisibleDespiteOwningModule() {
796 if (!isUnconditionallyVisible())
797 setModuleOwnershipKind(ModuleOwnershipKind::Visible);
798 }
799
800 /// Get the kind of module ownership for this declaration.
801 ModuleOwnershipKind getModuleOwnershipKind() const {
802 return NextInContextAndBits.getInt();
803 }
804
805 /// Set whether this declaration is hidden from name lookup.
806 void setModuleOwnershipKind(ModuleOwnershipKind MOK) {
807 assert(!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned &&((void)0)
808 MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() &&((void)0)
809 !hasLocalOwningModuleStorage()) &&((void)0)
810 "no storage available for owning module for this declaration")((void)0);
811 NextInContextAndBits.setInt(MOK);
812 }
813
814 unsigned getIdentifierNamespace() const {
815 return IdentifierNamespace;
816 }
817
818 bool isInIdentifierNamespace(unsigned NS) const {
819 return getIdentifierNamespace() & NS;
820 }
821
822 static unsigned getIdentifierNamespaceForKind(Kind DK);
823
824 bool hasTagIdentifierNamespace() const {
825 return isTagIdentifierNamespace(getIdentifierNamespace());
826 }
827
828 static bool isTagIdentifierNamespace(unsigned NS) {
829 // TagDecls have Tag and Type set and may also have TagFriend.
830 return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type);
831 }
832
833 /// getLexicalDeclContext - The declaration context where this Decl was
834 /// lexically declared (LexicalDC). May be different from
835 /// getDeclContext() (SemanticDC).
836 /// e.g.:
837 ///
838 /// namespace A {
839 /// void f(); // SemanticDC == LexicalDC == 'namespace A'
840 /// }
841 /// void A::f(); // SemanticDC == namespace 'A'
842 /// // LexicalDC == global namespace
843 DeclContext *getLexicalDeclContext() {
844 if (isInSemaDC())
845 return getSemanticDC();
846 return getMultipleDC()->LexicalDC;
847 }
848 const DeclContext *getLexicalDeclContext() const {
849 return const_cast<Decl*>(this)->getLexicalDeclContext();
850 }
851
852 /// Determine whether this declaration is declared out of line (outside its
853 /// semantic context).
854 virtual bool isOutOfLine() const;
855
856 /// setDeclContext - Set both the semantic and lexical DeclContext
857 /// to DC.
858 void setDeclContext(DeclContext *DC);
859
860 void setLexicalDeclContext(DeclContext *DC);
861
862 /// Determine whether this declaration is a templated entity (whether it is
863 // within the scope of a template parameter).
864 bool isTemplated() const;
865
866 /// Determine the number of levels of template parameter surrounding this
867 /// declaration.
868 unsigned getTemplateDepth() const;
869
870 /// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
871 /// scoped decl is defined outside the current function or method. This is
872 /// roughly global variables and functions, but also handles enums (which
873 /// could be defined inside or outside a function etc).
874 bool isDefinedOutsideFunctionOrMethod() const {
875 return getParentFunctionOrMethod() == nullptr;
876 }
877
878 /// Determine whether a substitution into this declaration would occur as
879 /// part of a substitution into a dependent local scope. Such a substitution
880 /// transitively substitutes into all constructs nested within this
881 /// declaration.
882 ///
883 /// This recognizes non-defining declarations as well as members of local
884 /// classes and lambdas:
885 /// \code
886 /// template<typename T> void foo() { void bar(); }
887 /// template<typename T> void foo2() { class ABC { void bar(); }; }
888 /// template<typename T> inline int x = [](){ return 0; }();
889 /// \endcode
890 bool isInLocalScopeForInstantiation() const;
891
892 /// If this decl is defined inside a function/method/block it returns
893 /// the corresponding DeclContext, otherwise it returns null.
894 const DeclContext *getParentFunctionOrMethod() const;
895 DeclContext *getParentFunctionOrMethod() {
896 return const_cast<DeclContext*>(
897 const_cast<const Decl*>(this)->getParentFunctionOrMethod());
898 }
899
900 /// Retrieves the "canonical" declaration of the given declaration.
901 virtual Decl *getCanonicalDecl() { return this; }
902 const Decl *getCanonicalDecl() const {
903 return const_cast<Decl*>(this)->getCanonicalDecl();
904 }
905
906 /// Whether this particular Decl is a canonical one.
907 bool isCanonicalDecl() const { return getCanonicalDecl() == this; }
908
909protected:
910 /// Returns the next redeclaration or itself if this is the only decl.
911 ///
912 /// Decl subclasses that can be redeclared should override this method so that
913 /// Decl::redecl_iterator can iterate over them.
914 virtual Decl *getNextRedeclarationImpl() { return this; }
915
916 /// Implementation of getPreviousDecl(), to be overridden by any
917 /// subclass that has a redeclaration chain.
918 virtual Decl *getPreviousDeclImpl() { return nullptr; }
919
920 /// Implementation of getMostRecentDecl(), to be overridden by any
921 /// subclass that has a redeclaration chain.
922 virtual Decl *getMostRecentDeclImpl() { return this; }
923
924public:
925 /// Iterates through all the redeclarations of the same decl.
926 class redecl_iterator {
927 /// Current - The current declaration.
928 Decl *Current = nullptr;
929 Decl *Starter;
930
931 public:
932 using value_type = Decl *;
933 using reference = const value_type &;
934 using pointer = const value_type *;
935 using iterator_category = std::forward_iterator_tag;
936 using difference_type = std::ptrdiff_t;
937
938 redecl_iterator() = default;
939 explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {}
940
941 reference operator*() const { return Current; }
942 value_type operator->() const { return Current; }
943
944 redecl_iterator& operator++() {
945 assert(Current && "Advancing while iterator has reached end")((void)0);
946 // Get either previous decl or latest decl.
947 Decl *Next = Current->getNextRedeclarationImpl();
948 assert(Next && "Should return next redeclaration or itself, never null!")((void)0);
949 Current = (Next != Starter) ? Next : nullptr;
950 return *this;
951 }
952
953 redecl_iterator operator++(int) {
954 redecl_iterator tmp(*this);
955 ++(*this);
956 return tmp;
957 }
958
959 friend bool operator==(redecl_iterator x, redecl_iterator y) {
960 return x.Current == y.Current;
961 }
962
963 friend bool operator!=(redecl_iterator x, redecl_iterator y) {
964 return x.Current != y.Current;
965 }
966 };
967
968 using redecl_range = llvm::iterator_range<redecl_iterator>;
969
970 /// Returns an iterator range for all the redeclarations of the same
971 /// decl. It will iterate at least once (when this decl is the only one).
972 redecl_range redecls() const {
973 return redecl_range(redecls_begin(), redecls_end());
974 }
975
976 redecl_iterator redecls_begin() const {
977 return redecl_iterator(const_cast<Decl *>(this));
978 }
979
980 redecl_iterator redecls_end() const { return redecl_iterator(); }
981
982 /// Retrieve the previous declaration that declares the same entity
983 /// as this declaration, or NULL if there is no previous declaration.
984 Decl *getPreviousDecl() { return getPreviousDeclImpl(); }
985
986 /// Retrieve the previous declaration that declares the same entity
987 /// as this declaration, or NULL if there is no previous declaration.
988 const Decl *getPreviousDecl() const {
989 return const_cast<Decl *>(this)->getPreviousDeclImpl();
990 }
991
992 /// True if this is the first declaration in its redeclaration chain.
993 bool isFirstDecl() const {
994 return getPreviousDecl() == nullptr;
995 }
996
997 /// Retrieve the most recent declaration that declares the same entity
998 /// as this declaration (which may be this declaration).
999 Decl *getMostRecentDecl() { return getMostRecentDeclImpl(); }
1000
1001 /// Retrieve the most recent declaration that declares the same entity
1002 /// as this declaration (which may be this declaration).
1003 const Decl *getMostRecentDecl() const {
1004 return const_cast<Decl *>(this)->getMostRecentDeclImpl();
1005 }
1006
1007 /// getBody - If this Decl represents a declaration for a body of code,
1008 /// such as a function or method definition, this method returns the
1009 /// top-level Stmt* of that body. Otherwise this method returns null.
1010 virtual Stmt* getBody() const { return nullptr; }
1011
1012 /// Returns true if this \c Decl represents a declaration for a body of
1013 /// code, such as a function or method definition.
1014 /// Note that \c hasBody can also return true if any redeclaration of this
1015 /// \c Decl represents a declaration for a body of code.
1016 virtual bool hasBody() const { return getBody() != nullptr; }
1017
1018 /// getBodyRBrace - Gets the right brace of the body, if a body exists.
1019 /// This works whether the body is a CompoundStmt or a CXXTryStmt.
1020 SourceLocation getBodyRBrace() const;
1021
1022 // global temp stats (until we have a per-module visitor)
1023 static void add(Kind k);
1024 static void EnableStatistics();
1025 static void PrintStats();
1026
1027 /// isTemplateParameter - Determines whether this declaration is a
1028 /// template parameter.
1029 bool isTemplateParameter() const;
1030
1031 /// isTemplateParameter - Determines whether this declaration is a
1032 /// template parameter pack.
1033 bool isTemplateParameterPack() const;
1034
1035 /// Whether this declaration is a parameter pack.
1036 bool isParameterPack() const;
1037
1038 /// returns true if this declaration is a template
1039 bool isTemplateDecl() const;
1040
1041 /// Whether this declaration is a function or function template.
1042 bool isFunctionOrFunctionTemplate() const {
1043 return (DeclKind >= Decl::firstFunction &&
1044 DeclKind <= Decl::lastFunction) ||
1045 DeclKind == FunctionTemplate;
1046 }
1047
1048 /// If this is a declaration that describes some template, this
1049 /// method returns that template declaration.
1050 ///
1051 /// Note that this returns nullptr for partial specializations, because they
1052 /// are not modeled as TemplateDecls. Use getDescribedTemplateParams to handle
1053 /// those cases.
1054 TemplateDecl *getDescribedTemplate() const;
1055
1056 /// If this is a declaration that describes some template or partial
1057 /// specialization, this returns the corresponding template parameter list.
1058 const TemplateParameterList *getDescribedTemplateParams() const;
1059
1060 /// Returns the function itself, or the templated function if this is a
1061 /// function template.
1062 FunctionDecl *getAsFunction() LLVM_READONLY__attribute__((__pure__));
1063
1064 const FunctionDecl *getAsFunction() const {
1065 return const_cast<Decl *>(this)->getAsFunction();
1066 }
1067
1068 /// Changes the namespace of this declaration to reflect that it's
1069 /// a function-local extern declaration.
1070 ///
1071 /// These declarations appear in the lexical context of the extern
1072 /// declaration, but in the semantic context of the enclosing namespace
1073 /// scope.
1074 void setLocalExternDecl() {
1075 Decl *Prev = getPreviousDecl();
1076 IdentifierNamespace &= ~IDNS_Ordinary;
1077
1078 // It's OK for the declaration to still have the "invisible friend" flag or
1079 // the "conflicts with tag declarations in this scope" flag for the outer
1080 // scope.
1081 assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 &&((void)0)
1082 "namespace is not ordinary")((void)0);
1083
1084 IdentifierNamespace |= IDNS_LocalExtern;
1085 if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)
1086 IdentifierNamespace |= IDNS_Ordinary;
1087 }
1088
1089 /// Determine whether this is a block-scope declaration with linkage.
1090 /// This will either be a local variable declaration declared 'extern', or a
1091 /// local function declaration.
1092 bool isLocalExternDecl() {
1093 return IdentifierNamespace & IDNS_LocalExtern;
1094 }
1095
1096 /// Changes the namespace of this declaration to reflect that it's
1097 /// the object of a friend declaration.
1098 ///
1099 /// These declarations appear in the lexical context of the friending
1100 /// class, but in the semantic context of the actual entity. This property
1101 /// applies only to a specific decl object; other redeclarations of the
1102 /// same entity may not (and probably don't) share this property.
1103 void setObjectOfFriendDecl(bool PerformFriendInjection = false) {
1104 unsigned OldNS = IdentifierNamespace;
1105 assert((OldNS & (IDNS_Tag | IDNS_Ordinary |((void)0)
1106 IDNS_TagFriend | IDNS_OrdinaryFriend |((void)0)
1107 IDNS_LocalExtern | IDNS_NonMemberOperator)) &&((void)0)
1108 "namespace includes neither ordinary nor tag")((void)0);
1109 assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type |((void)0)
1110 IDNS_TagFriend | IDNS_OrdinaryFriend |((void)0)
1111 IDNS_LocalExtern | IDNS_NonMemberOperator)) &&((void)0)
1112 "namespace includes other than ordinary or tag")((void)0);
1113
1114 Decl *Prev = getPreviousDecl();
1115 IdentifierNamespace &= ~(IDNS_Ordinary | IDNS_Tag | IDNS_Type);
1116
1117 if (OldNS & (IDNS_Tag | IDNS_TagFriend)) {
1118 IdentifierNamespace |= IDNS_TagFriend;
1119 if (PerformFriendInjection ||
1120 (Prev && Prev->getIdentifierNamespace() & IDNS_Tag))
1121 IdentifierNamespace |= IDNS_Tag | IDNS_Type;
1122 }
1123
1124 if (OldNS & (IDNS_Ordinary | IDNS_OrdinaryFriend |
1125 IDNS_LocalExtern | IDNS_NonMemberOperator)) {
1126 IdentifierNamespace |= IDNS_OrdinaryFriend;
1127 if (PerformFriendInjection ||
1128 (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary))
1129 IdentifierNamespace |= IDNS_Ordinary;
1130 }
1131 }
1132
1133 enum FriendObjectKind {
1134 FOK_None, ///< Not a friend object.
1135 FOK_Declared, ///< A friend of a previously-declared entity.
1136 FOK_Undeclared ///< A friend of a previously-undeclared entity.
1137 };
1138
1139 /// Determines whether this declaration is the object of a
1140 /// friend declaration and, if so, what kind.
1141 ///
1142 /// There is currently no direct way to find the associated FriendDecl.
1143 FriendObjectKind getFriendObjectKind() const {
1144 unsigned mask =
1145 (IdentifierNamespace & (IDNS_TagFriend | IDNS_OrdinaryFriend));
1146 if (!mask) return FOK_None;
1147 return (IdentifierNamespace & (IDNS_Tag | IDNS_Ordinary) ? FOK_Declared
1148 : FOK_Undeclared);
1149 }
1150
1151 /// Specifies that this declaration is a C++ overloaded non-member.
1152 void setNonMemberOperator() {
1153 assert(getKind() == Function || getKind() == FunctionTemplate)((void)0);
1154 assert((IdentifierNamespace & IDNS_Ordinary) &&((void)0)
1155 "visible non-member operators should be in ordinary namespace")((void)0);
1156 IdentifierNamespace |= IDNS_NonMemberOperator;
1157 }
1158
1159 static bool classofKind(Kind K) { return true; }
1160 static DeclContext *castToDeclContext(const Decl *);
1161 static Decl *castFromDeclContext(const DeclContext *);
1162
1163 void print(raw_ostream &Out, unsigned Indentation = 0,
1164 bool PrintInstantiation = false) const;
1165 void print(raw_ostream &Out, const PrintingPolicy &Policy,
1166 unsigned Indentation = 0, bool PrintInstantiation = false) const;
1167 static void printGroup(Decl** Begin, unsigned NumDecls,
1168 raw_ostream &Out, const PrintingPolicy &Policy,
1169 unsigned Indentation = 0);
1170
1171 // Debuggers don't usually respect default arguments.
1172 void dump() const;
1173
1174 // Same as dump(), but forces color printing.
1175 void dumpColor() const;
1176
1177 void dump(raw_ostream &Out, bool Deserialize = false,
1178 ASTDumpOutputFormat OutputFormat = ADOF_Default) const;
1179
1180 /// \return Unique reproducible object identifier
1181 int64_t getID() const;
1182
1183 /// Looks through the Decl's underlying type to extract a FunctionType
1184 /// when possible. Will return null if the type underlying the Decl does not
1185 /// have a FunctionType.
1186 const FunctionType *getFunctionType(bool BlocksToo = true) const;
1187
1188private:
1189 void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx);
1190 void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
1191 ASTContext &Ctx);
1192
1193protected:
1194 ASTMutationListener *getASTMutationListener() const;
1195};
1196
1197/// Determine whether two declarations declare the same entity.
1198inline bool declaresSameEntity(const Decl *D1, const Decl *D2) {
1199 if (!D1 || !D2)
1200 return false;
1201
1202 if (D1 == D2)
1203 return true;
1204
1205 return D1->getCanonicalDecl() == D2->getCanonicalDecl();
1206}
1207
1208/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
1209/// doing something to a specific decl.
1210class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
1211 const Decl *TheDecl;
1212 SourceLocation Loc;
1213 SourceManager &SM;
1214 const char *Message;
1215
1216public:
1217 PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L,
1218 SourceManager &sm, const char *Msg)
1219 : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {}
1220
1221 void print(raw_ostream &OS) const override;
1222};
1223} // namespace clang
1224
1225// Required to determine the layout of the PointerUnion<NamedDecl*> before
1226// seeing the NamedDecl definition being first used in DeclListNode::operator*.
1227namespace llvm {
1228 template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> {
1229 static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; }
1230 static inline ::clang::NamedDecl *getFromVoidPointer(void *P) {
1231 return static_cast<::clang::NamedDecl *>(P);
1232 }
1233 static constexpr int NumLowBitsAvailable = 3;
1234 };
1235}
1236
1237namespace clang {
1238/// A list storing NamedDecls in the lookup tables.
1239class DeclListNode {
1240 friend class ASTContext; // allocate, deallocate nodes.
1241 friend class StoredDeclsList;
1242public:
1243 using Decls = llvm::PointerUnion<NamedDecl*, DeclListNode*>;
1244 class iterator {
1245 friend class DeclContextLookupResult;
1246 friend class StoredDeclsList;
1247
1248 Decls Ptr;
1249 iterator(Decls Node) : Ptr(Node) { }
1250 public:
1251 using difference_type = ptrdiff_t;
1252 using value_type = NamedDecl*;
1253 using pointer = void;
1254 using reference = value_type;
1255 using iterator_category = std::forward_iterator_tag;
1256
1257 iterator() = default;
1258
1259 reference operator*() const {
1260 assert(Ptr && "dereferencing end() iterator")((void)0);
1261 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
1262 return CurNode->D;
1263 return Ptr.get<NamedDecl*>();
1264 }
1265 void operator->() const { } // Unsupported.
1266 bool operator==(const iterator &X) const { return Ptr == X.Ptr; }
1267 bool operator!=(const iterator &X) const { return Ptr != X.Ptr; }
1268 inline iterator &operator++() { // ++It
1269 assert(!Ptr.isNull() && "Advancing empty iterator")((void)0);
1270
1271 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
1272 Ptr = CurNode->Rest;
1273 else
1274 Ptr = nullptr;
1275 return *this;
1276 }
1277 iterator operator++(int) { // It++
1278 iterator temp = *this;
1279 ++(*this);
1280 return temp;
1281 }
1282 // Enables the pattern for (iterator I =..., E = I.end(); I != E; ++I)
1283 iterator end() { return iterator(); }
1284 };
1285private:
1286 NamedDecl *D = nullptr;
1287 Decls Rest = nullptr;
1288 DeclListNode(NamedDecl *ND) : D(ND) {}
1289};
1290
1291/// The results of name lookup within a DeclContext.
1292class DeclContextLookupResult {
1293 using Decls = DeclListNode::Decls;
1294
1295 /// When in collection form, this is what the Data pointer points to.
1296 Decls Result;
1297
1298public:
1299 DeclContextLookupResult() = default;
1300 DeclContextLookupResult(Decls Result) : Result(Result) {}
1301
1302 using iterator = DeclListNode::iterator;
1303 using const_iterator = iterator;
1304 using reference = iterator::reference;
1305
1306 iterator begin() { return iterator(Result); }
1307 iterator end() { return iterator(); }
1308 const_iterator begin() const {
1309 return const_cast<DeclContextLookupResult*>(this)->begin();
1310 }
1311 const_iterator end() const { return iterator(); }
1312
1313 bool empty() const { return Result.isNull(); }
1314 bool isSingleResult() const { return Result.dyn_cast<NamedDecl*>(); }
1315 reference front() const { return *begin(); }
1316
1317 // Find the first declaration of the given type in the list. Note that this
1318 // is not in general the earliest-declared declaration, and should only be
1319 // used when it's not possible for there to be more than one match or where
1320 // it doesn't matter which one is found.
1321 template<class T> T *find_first() const {
1322 for (auto *D : *this)
1323 if (T *Decl = dyn_cast<T>(D))
1324 return Decl;
1325
1326 return nullptr;
1327 }
1328};
1329
1330/// DeclContext - This is used only as base class of specific decl types that
1331/// can act as declaration contexts. These decls are (only the top classes
1332/// that directly derive from DeclContext are mentioned, not their subclasses):
1333///
1334/// TranslationUnitDecl
1335/// ExternCContext
1336/// NamespaceDecl
1337/// TagDecl
1338/// OMPDeclareReductionDecl
1339/// OMPDeclareMapperDecl
1340/// FunctionDecl
1341/// ObjCMethodDecl
1342/// ObjCContainerDecl
1343/// LinkageSpecDecl
1344/// ExportDecl
1345/// BlockDecl
1346/// CapturedDecl
1347class DeclContext {
1348 /// For makeDeclVisibleInContextImpl
1349 friend class ASTDeclReader;
1350 /// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
1351 /// hasNeedToReconcileExternalVisibleStorage
1352 friend class ExternalASTSource;
1353 /// For CreateStoredDeclsMap
1354 friend class DependentDiagnostic;
1355 /// For hasNeedToReconcileExternalVisibleStorage,
1356 /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
1357 friend class ASTWriter;
1358
1359 // We use uint64_t in the bit-fields below since some bit-fields
1360 // cross the unsigned boundary and this breaks the packing.
1361
1362 /// Stores the bits used by DeclContext.
1363 /// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
1364 /// methods in DeclContext should be updated appropriately.
1365 class DeclContextBitfields {
1366 friend class DeclContext;
1367 /// DeclKind - This indicates which class this is.
1368 uint64_t DeclKind : 7;
1369
1370 /// Whether this declaration context also has some external
1371 /// storage that contains additional declarations that are lexically
1372 /// part of this context.
1373 mutable uint64_t ExternalLexicalStorage : 1;
1374
1375 /// Whether this declaration context also has some external
1376 /// storage that contains additional declarations that are visible
1377 /// in this context.
1378 mutable uint64_t ExternalVisibleStorage : 1;
1379
1380 /// Whether this declaration context has had externally visible
1381 /// storage added since the last lookup. In this case, \c LookupPtr's
1382 /// invariant may not hold and needs to be fixed before we perform
1383 /// another lookup.
1384 mutable uint64_t NeedToReconcileExternalVisibleStorage : 1;
1385
1386 /// If \c true, this context may have local lexical declarations
1387 /// that are missing from the lookup table.
1388 mutable uint64_t HasLazyLocalLexicalLookups : 1;
1389
1390 /// If \c true, the external source may have lexical declarations
1391 /// that are missing from the lookup table.
1392 mutable uint64_t HasLazyExternalLexicalLookups : 1;
1393
1394 /// If \c true, lookups should only return identifier from
1395 /// DeclContext scope (for example TranslationUnit). Used in
1396 /// LookupQualifiedName()
1397 mutable uint64_t UseQualifiedLookup : 1;
1398 };
1399
1400 /// Number of bits in DeclContextBitfields.
1401 enum { NumDeclContextBits = 13 };
1402
1403 /// Stores the bits used by TagDecl.
1404 /// If modified NumTagDeclBits and the accessor
1405 /// methods in TagDecl should be updated appropriately.
1406 class TagDeclBitfields {
1407 friend class TagDecl;
1408 /// For the bits in DeclContextBitfields
1409 uint64_t : NumDeclContextBits;
1410
1411 /// The TagKind enum.
1412 uint64_t TagDeclKind : 3;
1413
1414 /// True if this is a definition ("struct foo {};"), false if it is a
1415 /// declaration ("struct foo;"). It is not considered a definition
1416 /// until the definition has been fully processed.
1417 uint64_t IsCompleteDefinition : 1;
1418
1419 /// True if this is currently being defined.
1420 uint64_t IsBeingDefined : 1;
1421
1422 /// True if this tag declaration is "embedded" (i.e., defined or declared
1423 /// for the very first time) in the syntax of a declarator.
1424 uint64_t IsEmbeddedInDeclarator : 1;
1425
1426 /// True if this tag is free standing, e.g. "struct foo;".
1427 uint64_t IsFreeStanding : 1;
1428
1429 /// Indicates whether it is possible for declarations of this kind
1430 /// to have an out-of-date definition.
1431 ///
1432 /// This option is only enabled when modules are enabled.
1433 uint64_t MayHaveOutOfDateDef : 1;
1434
1435 /// Has the full definition of this type been required by a use somewhere in
1436 /// the TU.
1437 uint64_t IsCompleteDefinitionRequired : 1;
1438 };
1439
1440 /// Number of non-inherited bits in TagDeclBitfields.
1441 enum { NumTagDeclBits = 9 };
1442
1443 /// Stores the bits used by EnumDecl.
1444 /// If modified NumEnumDeclBit and the accessor
1445 /// methods in EnumDecl should be updated appropriately.
1446 class EnumDeclBitfields {
1447 friend class EnumDecl;
1448 /// For the bits in DeclContextBitfields.
1449 uint64_t : NumDeclContextBits;
1450 /// For the bits in TagDeclBitfields.
1451 uint64_t : NumTagDeclBits;
1452
1453 /// Width in bits required to store all the non-negative
1454 /// enumerators of this enum.
1455 uint64_t NumPositiveBits : 8;
1456
1457 /// Width in bits required to store all the negative
1458 /// enumerators of this enum.
1459 uint64_t NumNegativeBits : 8;
1460
1461 /// True if this tag declaration is a scoped enumeration. Only
1462 /// possible in C++11 mode.
1463 uint64_t IsScoped : 1;
1464
1465 /// If this tag declaration is a scoped enum,
1466 /// then this is true if the scoped enum was declared using the class
1467 /// tag, false if it was declared with the struct tag. No meaning is
1468 /// associated if this tag declaration is not a scoped enum.
1469 uint64_t IsScopedUsingClassTag : 1;
1470
1471 /// True if this is an enumeration with fixed underlying type. Only
1472 /// possible in C++11, Microsoft extensions, or Objective C mode.
1473 uint64_t IsFixed : 1;
1474
1475 /// True if a valid hash is stored in ODRHash.
1476 uint64_t HasODRHash : 1;
1477 };
1478
1479 /// Number of non-inherited bits in EnumDeclBitfields.
1480 enum { NumEnumDeclBits = 20 };
1481
1482 /// Stores the bits used by RecordDecl.
1483 /// If modified NumRecordDeclBits and the accessor
1484 /// methods in RecordDecl should be updated appropriately.
1485 class RecordDeclBitfields {
1486 friend class RecordDecl;
1487 /// For the bits in DeclContextBitfields.
1488 uint64_t : NumDeclContextBits;
1489 /// For the bits in TagDeclBitfields.
1490 uint64_t : NumTagDeclBits;
1491
1492 /// This is true if this struct ends with a flexible
1493 /// array member (e.g. int X[]) or if this union contains a struct that does.
1494 /// If so, this cannot be contained in arrays or other structs as a member.
1495 uint64_t HasFlexibleArrayMember : 1;
1496
1497 /// Whether this is the type of an anonymous struct or union.
1498 uint64_t AnonymousStructOrUnion : 1;
1499
1500 /// This is true if this struct has at least one member
1501 /// containing an Objective-C object pointer type.
1502 uint64_t HasObjectMember : 1;
1503
1504 /// This is true if struct has at least one member of
1505 /// 'volatile' type.
1506 uint64_t HasVolatileMember : 1;
1507
1508 /// Whether the field declarations of this record have been loaded
1509 /// from external storage. To avoid unnecessary deserialization of
1510 /// methods/nested types we allow deserialization of just the fields
1511 /// when needed.
1512 mutable uint64_t LoadedFieldsFromExternalStorage : 1;
1513
1514 /// Basic properties of non-trivial C structs.
1515 uint64_t NonTrivialToPrimitiveDefaultInitialize : 1;
1516 uint64_t NonTrivialToPrimitiveCopy : 1;
1517 uint64_t NonTrivialToPrimitiveDestroy : 1;
1518
1519 /// The following bits indicate whether this is or contains a C union that
1520 /// is non-trivial to default-initialize, destruct, or copy. These bits
1521 /// imply the associated basic non-triviality predicates declared above.
1522 uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1;
1523 uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1;
1524 uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1;
1525
1526 /// Indicates whether this struct is destroyed in the callee.
1527 uint64_t ParamDestroyedInCallee : 1;
1528
1529 /// Represents the way this type is passed to a function.
1530 uint64_t ArgPassingRestrictions : 2;
1531 };
1532
1533 /// Number of non-inherited bits in RecordDeclBitfields.
1534 enum { NumRecordDeclBits = 14 };
1535
1536 /// Stores the bits used by OMPDeclareReductionDecl.
1537 /// If modified NumOMPDeclareReductionDeclBits and the accessor
1538 /// methods in OMPDeclareReductionDecl should be updated appropriately.
1539 class OMPDeclareReductionDeclBitfields {
1540 friend class OMPDeclareReductionDecl;
1541 /// For the bits in DeclContextBitfields
1542 uint64_t : NumDeclContextBits;
1543
1544 /// Kind of initializer,
1545 /// function call or omp_priv<init_expr> initializtion.
1546 uint64_t InitializerKind : 2;
1547 };
1548
1549 /// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
1550 enum { NumOMPDeclareReductionDeclBits = 2 };
1551
1552 /// Stores the bits used by FunctionDecl.
1553 /// If modified NumFunctionDeclBits and the accessor
1554 /// methods in FunctionDecl and CXXDeductionGuideDecl
1555 /// (for IsCopyDeductionCandidate) should be updated appropriately.
1556 class FunctionDeclBitfields {
1557 friend class FunctionDecl;
1558 /// For IsCopyDeductionCandidate
1559 friend class CXXDeductionGuideDecl;
1560 /// For the bits in DeclContextBitfields.
1561 uint64_t : NumDeclContextBits;
1562
1563 uint64_t SClass : 3;
1564 uint64_t IsInline : 1;
1565 uint64_t IsInlineSpecified : 1;
1566
1567 uint64_t IsVirtualAsWritten : 1;
1568 uint64_t IsPure : 1;
1569 uint64_t HasInheritedPrototype : 1;
1570 uint64_t HasWrittenPrototype : 1;
1571 uint64_t IsDeleted : 1;
1572 /// Used by CXXMethodDecl
1573 uint64_t IsTrivial : 1;
1574
1575 /// This flag indicates whether this function is trivial for the purpose of
1576 /// calls. This is meaningful only when this function is a copy/move
1577 /// constructor or a destructor.
1578 uint64_t IsTrivialForCall : 1;
1579
1580 uint64_t IsDefaulted : 1;
1581 uint64_t IsExplicitlyDefaulted : 1;
1582 uint64_t HasDefaultedFunctionInfo : 1;
1583 uint64_t HasImplicitReturnZero : 1;
1584 uint64_t IsLateTemplateParsed : 1;
1585
1586 /// Kind of contexpr specifier as defined by ConstexprSpecKind.
1587 uint64_t ConstexprKind : 2;
1588 uint64_t InstantiationIsPending : 1;
1589
1590 /// Indicates if the function uses __try.
1591 uint64_t UsesSEHTry : 1;
1592
1593 /// Indicates if the function was a definition
1594 /// but its body was skipped.
1595 uint64_t HasSkippedBody : 1;
1596
1597 /// Indicates if the function declaration will
1598 /// have a body, once we're done parsing it.
1599 uint64_t WillHaveBody : 1;
1600
1601 /// Indicates that this function is a multiversioned
1602 /// function using attribute 'target'.
1603 uint64_t IsMultiVersion : 1;
1604
1605 /// [C++17] Only used by CXXDeductionGuideDecl. Indicates that
1606 /// the Deduction Guide is the implicitly generated 'copy
1607 /// deduction candidate' (is used during overload resolution).
1608 uint64_t IsCopyDeductionCandidate : 1;
1609
1610 /// Store the ODRHash after first calculation.
1611 uint64_t HasODRHash : 1;
1612
1613 /// Indicates if the function uses Floating Point Constrained Intrinsics
1614 uint64_t UsesFPIntrin : 1;
1615 };
1616
1617 /// Number of non-inherited bits in FunctionDeclBitfields.
1618 enum { NumFunctionDeclBits = 27 };
1619
1620 /// Stores the bits used by CXXConstructorDecl. If modified
1621 /// NumCXXConstructorDeclBits and the accessor
1622 /// methods in CXXConstructorDecl should be updated appropriately.
1623 class CXXConstructorDeclBitfields {
1624 friend class CXXConstructorDecl;
1625 /// For the bits in DeclContextBitfields.
1626 uint64_t : NumDeclContextBits;
1627 /// For the bits in FunctionDeclBitfields.
1628 uint64_t : NumFunctionDeclBits;
1629
1630 /// 24 bits to fit in the remaining available space.
1631 /// Note that this makes CXXConstructorDeclBitfields take
1632 /// exactly 64 bits and thus the width of NumCtorInitializers
1633 /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
1634 /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
1635 uint64_t NumCtorInitializers : 21;
1636 uint64_t IsInheritingConstructor : 1;
1637
1638 /// Whether this constructor has a trail-allocated explicit specifier.
1639 uint64_t HasTrailingExplicitSpecifier : 1;
1640 /// If this constructor does't have a trail-allocated explicit specifier.
1641 /// Whether this constructor is explicit specified.
1642 uint64_t IsSimpleExplicit : 1;
1643 };
1644
1645 /// Number of non-inherited bits in CXXConstructorDeclBitfields.
1646 enum {
1647 NumCXXConstructorDeclBits = 64 - NumDeclContextBits - NumFunctionDeclBits
1648 };
1649
1650 /// Stores the bits used by ObjCMethodDecl.
1651 /// If modified NumObjCMethodDeclBits and the accessor
1652 /// methods in ObjCMethodDecl should be updated appropriately.
1653 class ObjCMethodDeclBitfields {
1654 friend class ObjCMethodDecl;
1655
1656 /// For the bits in DeclContextBitfields.
1657 uint64_t : NumDeclContextBits;
1658
1659 /// The conventional meaning of this method; an ObjCMethodFamily.
1660 /// This is not serialized; instead, it is computed on demand and
1661 /// cached.
1662 mutable uint64_t Family : ObjCMethodFamilyBitWidth;
1663
1664 /// instance (true) or class (false) method.
1665 uint64_t IsInstance : 1;
1666 uint64_t IsVariadic : 1;
1667
1668 /// True if this method is the getter or setter for an explicit property.
1669 uint64_t IsPropertyAccessor : 1;
1670
1671 /// True if this method is a synthesized property accessor stub.
1672 uint64_t IsSynthesizedAccessorStub : 1;
1673
1674 /// Method has a definition.
1675 uint64_t IsDefined : 1;
1676
1677 /// Method redeclaration in the same interface.
1678 uint64_t IsRedeclaration : 1;
1679
1680 /// Is redeclared in the same interface.
1681 mutable uint64_t HasRedeclaration : 1;
1682
1683 /// \@required/\@optional
1684 uint64_t DeclImplementation : 2;
1685
1686 /// in, inout, etc.
1687 uint64_t objcDeclQualifier : 7;
1688
1689 /// Indicates whether this method has a related result type.
1690 uint64_t RelatedResultType : 1;
1691
1692 /// Whether the locations of the selector identifiers are in a
1693 /// "standard" position, a enum SelectorLocationsKind.
1694 uint64_t SelLocsKind : 2;
1695
1696 /// Whether this method overrides any other in the class hierarchy.
1697 ///
1698 /// A method is said to override any method in the class's
1699 /// base classes, its protocols, or its categories' protocols, that has
1700 /// the same selector and is of the same kind (class or instance).
1701 /// A method in an implementation is not considered as overriding the same
1702 /// method in the interface or its categories.
1703 uint64_t IsOverriding : 1;
1704
1705 /// Indicates if the method was a definition but its body was skipped.
1706 uint64_t HasSkippedBody : 1;
1707 };
1708
1709 /// Number of non-inherited bits in ObjCMethodDeclBitfields.
1710 enum { NumObjCMethodDeclBits = 24 };
1711
1712 /// Stores the bits used by ObjCContainerDecl.
1713 /// If modified NumObjCContainerDeclBits and the accessor
1714 /// methods in ObjCContainerDecl should be updated appropriately.
1715 class ObjCContainerDeclBitfields {
1716 friend class ObjCContainerDecl;
1717 /// For the bits in DeclContextBitfields
1718 uint32_t : NumDeclContextBits;
1719
1720 // Not a bitfield but this saves space.
1721 // Note that ObjCContainerDeclBitfields is full.
1722 SourceLocation AtStart;
1723 };
1724
1725 /// Number of non-inherited bits in ObjCContainerDeclBitfields.
1726 /// Note that here we rely on the fact that SourceLocation is 32 bits
1727 /// wide. We check this with the static_assert in the ctor of DeclContext.
1728 enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };
1729
1730 /// Stores the bits used by LinkageSpecDecl.
1731 /// If modified NumLinkageSpecDeclBits and the accessor
1732 /// methods in LinkageSpecDecl should be updated appropriately.
1733 class LinkageSpecDeclBitfields {
1734 friend class LinkageSpecDecl;
1735 /// For the bits in DeclContextBitfields.
1736 uint64_t : NumDeclContextBits;
1737
1738 /// The language for this linkage specification with values
1739 /// in the enum LinkageSpecDecl::LanguageIDs.
1740 uint64_t Language : 3;
1741
1742 /// True if this linkage spec has braces.
1743 /// This is needed so that hasBraces() returns the correct result while the
1744 /// linkage spec body is being parsed. Once RBraceLoc has been set this is
1745 /// not used, so it doesn't need to be serialized.
1746 uint64_t HasBraces : 1;
1747 };
1748
1749 /// Number of non-inherited bits in LinkageSpecDeclBitfields.
1750 enum { NumLinkageSpecDeclBits = 4 };
1751
1752 /// Stores the bits used by BlockDecl.
1753 /// If modified NumBlockDeclBits and the accessor
1754 /// methods in BlockDecl should be updated appropriately.
1755 class BlockDeclBitfields {
1756 friend class BlockDecl;
1757 /// For the bits in DeclContextBitfields.
1758 uint64_t : NumDeclContextBits;
1759
1760 uint64_t IsVariadic : 1;
1761 uint64_t CapturesCXXThis : 1;
1762 uint64_t BlockMissingReturnType : 1;
1763 uint64_t IsConversionFromLambda : 1;
1764
1765 /// A bit that indicates this block is passed directly to a function as a
1766 /// non-escaping parameter.
1767 uint64_t DoesNotEscape : 1;
1768
1769 /// A bit that indicates whether it's possible to avoid coying this block to
1770 /// the heap when it initializes or is assigned to a local variable with
1771 /// automatic storage.
1772 uint64_t CanAvoidCopyToHeap : 1;
1773 };
1774
1775 /// Number of non-inherited bits in BlockDeclBitfields.
1776 enum { NumBlockDeclBits = 5 };
1777
1778 /// Pointer to the data structure used to lookup declarations
1779 /// within this context (or a DependentStoredDeclsMap if this is a
1780 /// dependent context). We maintain the invariant that, if the map
1781 /// contains an entry for a DeclarationName (and we haven't lazily
1782 /// omitted anything), then it contains all relevant entries for that
1783 /// name (modulo the hasExternalDecls() flag).
1784 mutable StoredDeclsMap *LookupPtr = nullptr;
1785
1786protected:
1787 /// This anonymous union stores the bits belonging to DeclContext and classes
1788 /// deriving from it. The goal is to use otherwise wasted
1789 /// space in DeclContext to store data belonging to derived classes.
1790 /// The space saved is especially significient when pointers are aligned
1791 /// to 8 bytes. In this case due to alignment requirements we have a
1792 /// little less than 8 bytes free in DeclContext which we can use.
1793 /// We check that none of the classes in this union is larger than
1794 /// 8 bytes with static_asserts in the ctor of DeclContext.
1795 union {
1796 DeclContextBitfields DeclContextBits;
1797 TagDeclBitfields TagDeclBits;
1798 EnumDeclBitfields EnumDeclBits;
1799 RecordDeclBitfields RecordDeclBits;
1800 OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
1801 FunctionDeclBitfields FunctionDeclBits;
1802 CXXConstructorDeclBitfields CXXConstructorDeclBits;
1803 ObjCMethodDeclBitfields ObjCMethodDeclBits;
1804 ObjCContainerDeclBitfields ObjCContainerDeclBits;
1805 LinkageSpecDeclBitfields LinkageSpecDeclBits;
1806 BlockDeclBitfields BlockDeclBits;
1807
1808 static_assert(sizeof(DeclContextBitfields) <= 8,
1809 "DeclContextBitfields is larger than 8 bytes!");
1810 static_assert(sizeof(TagDeclBitfields) <= 8,
1811 "TagDeclBitfields is larger than 8 bytes!");
1812 static_assert(sizeof(EnumDeclBitfields) <= 8,
1813 "EnumDeclBitfields is larger than 8 bytes!");
1814 static_assert(sizeof(RecordDeclBitfields) <= 8,
1815 "RecordDeclBitfields is larger than 8 bytes!");
1816 static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
1817 "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
1818 static_assert(sizeof(FunctionDeclBitfields) <= 8,
1819 "FunctionDeclBitfields is larger than 8 bytes!");
1820 static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
1821 "CXXConstructorDeclBitfields is larger than 8 bytes!");
1822 static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
1823 "ObjCMethodDeclBitfields is larger than 8 bytes!");
1824 static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
1825 "ObjCContainerDeclBitfields is larger than 8 bytes!");
1826 static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
1827 "LinkageSpecDeclBitfields is larger than 8 bytes!");
1828 static_assert(sizeof(BlockDeclBitfields) <= 8,
1829 "BlockDeclBitfields is larger than 8 bytes!");
1830 };
1831
1832 /// FirstDecl - The first declaration stored within this declaration
1833 /// context.
1834 mutable Decl *FirstDecl = nullptr;
1835
1836 /// LastDecl - The last declaration stored within this declaration
1837 /// context. FIXME: We could probably cache this value somewhere
1838 /// outside of the DeclContext, to reduce the size of DeclContext by
1839 /// another pointer.
1840 mutable Decl *LastDecl = nullptr;
1841
1842 /// Build up a chain of declarations.
1843 ///
1844 /// \returns the first/last pair of declarations.
1845 static std::pair<Decl *, Decl *>
1846 BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded);
1847
1848 DeclContext(Decl::Kind K);
1849
1850public:
1851 ~DeclContext();
1852
1853 Decl::Kind getDeclKind() const {
1854 return static_cast<Decl::Kind>(DeclContextBits.DeclKind);
1855 }
1856
1857 const char *getDeclKindName() const;
1858
1859 /// getParent - Returns the containing DeclContext.
1860 DeclContext *getParent() {
1861 return cast<Decl>(this)->getDeclContext();
1862 }
1863 const DeclContext *getParent() const {
1864 return const_cast<DeclContext*>(this)->getParent();
1865 }
1866
1867 /// getLexicalParent - Returns the containing lexical DeclContext. May be
1868 /// different from getParent, e.g.:
1869 ///
1870 /// namespace A {
1871 /// struct S;
1872 /// }
1873 /// struct A::S {}; // getParent() == namespace 'A'
1874 /// // getLexicalParent() == translation unit
1875 ///
1876 DeclContext *getLexicalParent() {
1877 return cast<Decl>(this)->getLexicalDeclContext();
1878 }
1879 const DeclContext *getLexicalParent() const {
1880 return const_cast<DeclContext*>(this)->getLexicalParent();
1881 }
1882
1883 DeclContext *getLookupParent();
1884
1885 const DeclContext *getLookupParent() const {
1886 return const_cast<DeclContext*>(this)->getLookupParent();
1887 }
1888
1889 ASTContext &getParentASTContext() const {
1890 return cast<Decl>(this)->getASTContext();
1891 }
1892
1893 bool isClosure() const { return getDeclKind() == Decl::Block; }
1894
1895 /// Return this DeclContext if it is a BlockDecl. Otherwise, return the
1896 /// innermost enclosing BlockDecl or null if there are no enclosing blocks.
1897 const BlockDecl *getInnermostBlockDecl() const;
1898
1899 bool isObjCContainer() const {
1900 switch (getDeclKind()) {
1901 case Decl::ObjCCategory:
1902 case Decl::ObjCCategoryImpl:
1903 case Decl::ObjCImplementation:
1904 case Decl::ObjCInterface:
1905 case Decl::ObjCProtocol:
1906 return true;
1907 default:
1908 return false;
1909 }
1910 }
1911
1912 bool isFunctionOrMethod() const {
1913 switch (getDeclKind()) {
1914 case Decl::Block:
1915 case Decl::Captured:
1916 case Decl::ObjCMethod:
1917 return true;
1918 default:
1919 return getDeclKind() >= Decl::firstFunction &&
1920 getDeclKind() <= Decl::lastFunction;
1921 }
1922 }
1923
1924 /// Test whether the context supports looking up names.
1925 bool isLookupContext() const {
1926 return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec &&
1927 getDeclKind() != Decl::Export;
1928 }
1929
1930 bool isFileContext() const {
1931 return getDeclKind() == Decl::TranslationUnit ||
1932 getDeclKind() == Decl::Namespace;
1933 }
1934
1935 bool isTranslationUnit() const {
1936 return getDeclKind() == Decl::TranslationUnit;
1937 }
1938
1939 bool isRecord() const {
1940 return getDeclKind() >= Decl::firstRecord &&
1941 getDeclKind() <= Decl::lastRecord;
1942 }
1943
1944 bool isNamespace() const { return getDeclKind() == Decl::Namespace; }
1945
1946 bool isStdNamespace() const;
1947
1948 bool isInlineNamespace() const;
1949
1950 /// Determines whether this context is dependent on a
1951 /// template parameter.
1952 bool isDependentContext() const;
1953
1954 /// isTransparentContext - Determines whether this context is a
1955 /// "transparent" context, meaning that the members declared in this
1956 /// context are semantically declared in the nearest enclosing
1957 /// non-transparent (opaque) context but are lexically declared in
1958 /// this context. For example, consider the enumerators of an
1959 /// enumeration type:
1960 /// @code
1961 /// enum E {
1962 /// Val1
1963 /// };
1964 /// @endcode
1965 /// Here, E is a transparent context, so its enumerator (Val1) will
1966 /// appear (semantically) that it is in the same context of E.
1967 /// Examples of transparent contexts include: enumerations (except for
1968 /// C++0x scoped enums), and C++ linkage specifications.
1969 bool isTransparentContext() const;
1970
1971 /// Determines whether this context or some of its ancestors is a
1972 /// linkage specification context that specifies C linkage.
1973 bool isExternCContext() const;
1974
1975 /// Retrieve the nearest enclosing C linkage specification context.
1976 const LinkageSpecDecl *getExternCContext() const;
1977
1978 /// Determines whether this context or some of its ancestors is a
1979 /// linkage specification context that specifies C++ linkage.
1980 bool isExternCXXContext() const;
1981
1982 /// Determine whether this declaration context is equivalent
1983 /// to the declaration context DC.
1984 bool Equals(const DeclContext *DC) const {
1985 return DC && this->getPrimaryContext() == DC->getPrimaryContext();
1986 }
1987
1988 /// Determine whether this declaration context encloses the
1989 /// declaration context DC.
1990 bool Encloses(const DeclContext *DC) const;
1991
1992 /// Find the nearest non-closure ancestor of this context,
1993 /// i.e. the innermost semantic parent of this context which is not
1994 /// a closure. A context may be its own non-closure ancestor.
1995 Decl *getNonClosureAncestor();
1996 const Decl *getNonClosureAncestor() const {
1997 return const_cast<DeclContext*>(this)->getNonClosureAncestor();
1998 }
1999
2000 /// getPrimaryContext - There may be many different
2001 /// declarations of the same entity (including forward declarations
2002 /// of classes, multiple definitions of namespaces, etc.), each with
2003 /// a different set of declarations. This routine returns the
2004 /// "primary" DeclContext structure, which will contain the
2005 /// information needed to perform name lookup into this context.
2006 DeclContext *getPrimaryContext();
2007 const DeclContext *getPrimaryContext() const {
2008 return const_cast<DeclContext*>(this)->getPrimaryContext();
2009 }
2010
2011 /// getRedeclContext - Retrieve the context in which an entity conflicts with
2012 /// other entities of the same name, or where it is a redeclaration if the
2013 /// two entities are compatible. This skips through transparent contexts.
2014 DeclContext *getRedeclContext();
2015 const DeclContext *getRedeclContext() const {
2016 return const_cast<DeclContext *>(this)->getRedeclContext();
2017 }
2018
2019 /// Retrieve the nearest enclosing namespace context.
2020 DeclContext *getEnclosingNamespaceContext();
2021 const DeclContext *getEnclosingNamespaceContext() const {
2022 return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext();
2023 }
2024
2025 /// Retrieve the outermost lexically enclosing record context.
2026 RecordDecl *getOuterLexicalRecordContext();
2027 const RecordDecl *getOuterLexicalRecordContext() const {
2028 return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
2029 }
2030
2031 /// Test if this context is part of the enclosing namespace set of
2032 /// the context NS, as defined in C++0x [namespace.def]p9. If either context
2033 /// isn't a namespace, this is equivalent to Equals().
2034 ///
2035 /// The enclosing namespace set of a namespace is the namespace and, if it is
2036 /// inline, its enclosing namespace, recursively.
2037 bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;
2038
2039 /// Collects all of the declaration contexts that are semantically
2040 /// connected to this declaration context.
2041 ///
2042 /// For declaration contexts that have multiple semantically connected but
2043 /// syntactically distinct contexts, such as C++ namespaces, this routine
2044 /// retrieves the complete set of such declaration contexts in source order.
2045 /// For example, given:
2046 ///
2047 /// \code
2048 /// namespace N {
2049 /// int x;
2050 /// }
2051 /// namespace N {
2052 /// int y;
2053 /// }
2054 /// \endcode
2055 ///
2056 /// The \c Contexts parameter will contain both definitions of N.
2057 ///
2058 /// \param Contexts Will be cleared and set to the set of declaration
2059 /// contexts that are semanticaly connected to this declaration context,
2060 /// in source order, including this context (which may be the only result,
2061 /// for non-namespace contexts).
2062 void collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts);
2063
2064 /// decl_iterator - Iterates through the declarations stored
2065 /// within this context.
2066 class decl_iterator {
2067 /// Current - The current declaration.
2068 Decl *Current = nullptr;
2069
2070 public:
2071 using value_type = Decl *;
2072 using reference = const value_type &;
2073 using pointer = const value_type *;
2074 using iterator_category = std::forward_iterator_tag;
2075 using difference_type = std::ptrdiff_t;
2076
2077 decl_iterator() = default;
2078 explicit decl_iterator(Decl *C) : Current(C) {}
2079
2080 reference operator*() const { return Current; }
2081
2082 // This doesn't meet the iterator requirements, but it's convenient
2083 value_type operator->() const { return Current; }
2084
2085 decl_iterator& operator++() {
2086 Current = Current->getNextDeclInContext();
2087 return *this;
2088 }
2089
2090 decl_iterator operator++(int) {
2091 decl_iterator tmp(*this);
2092 ++(*this);
2093 return tmp;
2094 }
2095
2096 friend bool operator==(decl_iterator x, decl_iterator y) {
2097 return x.Current == y.Current;
18
Assuming 'x.Current' is equal to 'y.Current'
19
Returning the value 1, which participates in a condition later
2098 }
2099
2100 friend bool operator!=(decl_iterator x, decl_iterator y) {
2101 return x.Current != y.Current;
2102 }
2103 };
2104
2105 using decl_range = llvm::iterator_range<decl_iterator>;
2106
2107 /// decls_begin/decls_end - Iterate over the declarations stored in
2108 /// this context.
2109 decl_range decls() const { return decl_range(decls_begin(), decls_end()); }
2110 decl_iterator decls_begin() const;
2111 decl_iterator decls_end() const { return decl_iterator(); }
2112 bool decls_empty() const;
2113
2114 /// noload_decls_begin/end - Iterate over the declarations stored in this
2115 /// context that are currently loaded; don't attempt to retrieve anything
2116 /// from an external source.
2117 decl_range noload_decls() const {
2118 return decl_range(noload_decls_begin(), noload_decls_end());
2119 }
2120 decl_iterator noload_decls_begin() const { return decl_iterator(FirstDecl); }
2121 decl_iterator noload_decls_end() const { return decl_iterator(); }
2122
2123 /// specific_decl_iterator - Iterates over a subrange of
2124 /// declarations stored in a DeclContext, providing only those that
2125 /// are of type SpecificDecl (or a class derived from it). This
2126 /// iterator is used, for example, to provide iteration over just
2127 /// the fields within a RecordDecl (with SpecificDecl = FieldDecl).
2128 template<typename SpecificDecl>
2129 class specific_decl_iterator {
2130 /// Current - The current, underlying declaration iterator, which
2131 /// will either be NULL or will point to a declaration of
2132 /// type SpecificDecl.
2133 DeclContext::decl_iterator Current;
2134
2135 /// SkipToNextDecl - Advances the current position up to the next
2136 /// declaration of type SpecificDecl that also meets the criteria
2137 /// required by Acceptable.
2138 void SkipToNextDecl() {
2139 while (*Current && !isa<SpecificDecl>(*Current))
2140 ++Current;
2141 }
2142
2143 public:
2144 using value_type = SpecificDecl *;
2145 // TODO: Add reference and pointer types (with some appropriate proxy type)
2146 // if we ever have a need for them.
2147 using reference = void;
2148 using pointer = void;
2149 using difference_type =
2150 std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2151 using iterator_category = std::forward_iterator_tag;
2152
2153 specific_decl_iterator() = default;
2154
2155 /// specific_decl_iterator - Construct a new iterator over a
2156 /// subset of the declarations the range [C,
2157 /// end-of-declarations). If A is non-NULL, it is a pointer to a
2158 /// member function of SpecificDecl that should return true for
2159 /// all of the SpecificDecl instances that will be in the subset
2160 /// of iterators. For example, if you want Objective-C instance
2161 /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2162 /// &ObjCMethodDecl::isInstanceMethod.
2163 explicit specific_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
2164 SkipToNextDecl();
2165 }
2166
2167 value_type operator*() const { return cast<SpecificDecl>(*Current); }
2168
2169 // This doesn't meet the iterator requirements, but it's convenient
2170 value_type operator->() const { return **this; }
2171
2172 specific_decl_iterator& operator++() {
2173 ++Current;
2174 SkipToNextDecl();
2175 return *this;
2176 }
2177
2178 specific_decl_iterator operator++(int) {
2179 specific_decl_iterator tmp(*this);
2180 ++(*this);
2181 return tmp;
2182 }
2183
2184 friend bool operator==(const specific_decl_iterator& x,
2185 const specific_decl_iterator& y) {
2186 return x.Current == y.Current;
17
Calling 'operator=='
20
Returning from 'operator=='
21
Returning the value 1, which participates in a condition later
2187 }
2188
2189 friend bool operator!=(const specific_decl_iterator& x,
2190 const specific_decl_iterator& y) {
2191 return x.Current != y.Current;
2192 }
2193 };
2194
2195 /// Iterates over a filtered subrange of declarations stored
2196 /// in a DeclContext.
2197 ///
2198 /// This iterator visits only those declarations that are of type
2199 /// SpecificDecl (or a class derived from it) and that meet some
2200 /// additional run-time criteria. This iterator is used, for
2201 /// example, to provide access to the instance methods within an
2202 /// Objective-C interface (with SpecificDecl = ObjCMethodDecl and
2203 /// Acceptable = ObjCMethodDecl::isInstanceMethod).
2204 template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const>
2205 class filtered_decl_iterator {
2206 /// Current - The current, underlying declaration iterator, which
2207 /// will either be NULL or will point to a declaration of
2208 /// type SpecificDecl.
2209 DeclContext::decl_iterator Current;
2210
2211 /// SkipToNextDecl - Advances the current position up to the next
2212 /// declaration of type SpecificDecl that also meets the criteria
2213 /// required by Acceptable.
2214 void SkipToNextDecl() {
2215 while (*Current &&
2216 (!isa<SpecificDecl>(*Current) ||
2217 (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)())))
2218 ++Current;
2219 }
2220
2221 public:
2222 using value_type = SpecificDecl *;
2223 // TODO: Add reference and pointer types (with some appropriate proxy type)
2224 // if we ever have a need for them.
2225 using reference = void;
2226 using pointer = void;
2227 using difference_type =
2228 std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2229 using iterator_category = std::forward_iterator_tag;
2230
2231 filtered_decl_iterator() = default;
2232
2233 /// filtered_decl_iterator - Construct a new iterator over a
2234 /// subset of the declarations the range [C,
2235 /// end-of-declarations). If A is non-NULL, it is a pointer to a
2236 /// member function of SpecificDecl that should return true for
2237 /// all of the SpecificDecl instances that will be in the subset
2238 /// of iterators. For example, if you want Objective-C instance
2239 /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2240 /// &ObjCMethodDecl::isInstanceMethod.
2241 explicit filtered_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
2242 SkipToNextDecl();
2243 }
2244
2245 value_type operator*() const { return cast<SpecificDecl>(*Current); }
2246 value_type operator->() const { return cast<SpecificDecl>(*Current); }
2247
2248 filtered_decl_iterator& operator++() {
2249 ++Current;
2250 SkipToNextDecl();
2251 return *this;
2252 }
2253
2254 filtered_decl_iterator operator++(int) {
2255 filtered_decl_iterator tmp(*this);
2256 ++(*this);
2257 return tmp;
2258 }
2259
2260 friend bool operator==(const filtered_decl_iterator& x,
2261 const filtered_decl_iterator& y) {
2262 return x.Current == y.Current;
2263 }
2264
2265 friend bool operator!=(const filtered_decl_iterator& x,
2266 const filtered_decl_iterator& y) {
2267 return x.Current != y.Current;
2268 }
2269 };
2270
2271 /// Add the declaration D into this context.
2272 ///
2273 /// This routine should be invoked when the declaration D has first
2274 /// been declared, to place D into the context where it was
2275 /// (lexically) defined. Every declaration must be added to one
2276 /// (and only one!) context, where it can be visited via
2277 /// [decls_begin(), decls_end()). Once a declaration has been added
2278 /// to its lexical context, the corresponding DeclContext owns the
2279 /// declaration.
2280 ///
2281 /// If D is also a NamedDecl, it will be made visible within its
2282 /// semantic context via makeDeclVisibleInContext.
2283 void addDecl(Decl *D);
2284
2285 /// Add the declaration D into this context, but suppress
2286 /// searches for external declarations with the same name.
2287 ///
2288 /// Although analogous in function to addDecl, this removes an
2289 /// important check. This is only useful if the Decl is being
2290 /// added in response to an external search; in all other cases,
2291 /// addDecl() is the right function to use.
2292 /// See the ASTImporter for use cases.
2293 void addDeclInternal(Decl *D);
2294
2295 /// Add the declaration D to this context without modifying
2296 /// any lookup tables.
2297 ///
2298 /// This is useful for some operations in dependent contexts where
2299 /// the semantic context might not be dependent; this basically
2300 /// only happens with friends.
2301 void addHiddenDecl(Decl *D);
2302
2303 /// Removes a declaration from this context.
2304 void removeDecl(Decl *D);
2305
2306 /// Checks whether a declaration is in this context.
2307 bool containsDecl(Decl *D) const;
2308
2309 /// Checks whether a declaration is in this context.
2310 /// This also loads the Decls from the external source before the check.
2311 bool containsDeclAndLoad(Decl *D) const;
2312
2313 using lookup_result = DeclContextLookupResult;
2314 using lookup_iterator = lookup_result::iterator;
2315
2316 /// lookup - Find the declarations (if any) with the given Name in
2317 /// this context. Returns a range of iterators that contains all of
2318 /// the declarations with this name, with object, function, member,
2319 /// and enumerator names preceding any tag name. Note that this
2320 /// routine will not look into parent contexts.
2321 lookup_result lookup(DeclarationName Name) const;
2322
2323 /// Find the declarations with the given name that are visible
2324 /// within this context; don't attempt to retrieve anything from an
2325 /// external source.
2326 lookup_result noload_lookup(DeclarationName Name);
2327
2328 /// A simplistic name lookup mechanism that performs name lookup
2329 /// into this declaration context without consulting the external source.
2330 ///
2331 /// This function should almost never be used, because it subverts the
2332 /// usual relationship between a DeclContext and the external source.
2333 /// See the ASTImporter for the (few, but important) use cases.
2334 ///
2335 /// FIXME: This is very inefficient; replace uses of it with uses of
2336 /// noload_lookup.
2337 void localUncachedLookup(DeclarationName Name,
2338 SmallVectorImpl<NamedDecl *> &Results);
2339
2340 /// Makes a declaration visible within this context.
2341 ///
2342 /// This routine makes the declaration D visible to name lookup
2343 /// within this context and, if this is a transparent context,
2344 /// within its parent contexts up to the first enclosing
2345 /// non-transparent context. Making a declaration visible within a
2346 /// context does not transfer ownership of a declaration, and a
2347 /// declaration can be visible in many contexts that aren't its
2348 /// lexical context.
2349 ///
2350 /// If D is a redeclaration of an existing declaration that is
2351 /// visible from this context, as determined by
2352 /// NamedDecl::declarationReplaces, the previous declaration will be
2353 /// replaced with D.
2354 void makeDeclVisibleInContext(NamedDecl *D);
2355
2356 /// all_lookups_iterator - An iterator that provides a view over the results
2357 /// of looking up every possible name.
2358 class all_lookups_iterator;
2359
2360 using lookups_range = llvm::iterator_range<all_lookups_iterator>;
2361
2362 lookups_range lookups() const;
2363 // Like lookups(), but avoids loading external declarations.
2364 // If PreserveInternalState, avoids building lookup data structures too.
2365 lookups_range noload_lookups(bool PreserveInternalState) const;
2366
2367 /// Iterators over all possible lookups within this context.
2368 all_lookups_iterator lookups_begin() const;
2369 all_lookups_iterator lookups_end() const;
2370
2371 /// Iterators over all possible lookups within this context that are
2372 /// currently loaded; don't attempt to retrieve anything from an external
2373 /// source.
2374 all_lookups_iterator noload_lookups_begin() const;
2375 all_lookups_iterator noload_lookups_end() const;
2376
2377 struct udir_iterator;
2378
2379 using udir_iterator_base =
2380 llvm::iterator_adaptor_base<udir_iterator, lookup_iterator,
2381 typename lookup_iterator::iterator_category,
2382 UsingDirectiveDecl *>;
2383
2384 struct udir_iterator : udir_iterator_base {
2385 udir_iterator(lookup_iterator I) : udir_iterator_base(I) {}
2386
2387 UsingDirectiveDecl *operator*() const;
2388 };
2389
2390 using udir_range = llvm::iterator_range<udir_iterator>;
2391
2392 udir_range using_directives() const;
2393
2394 // These are all defined in DependentDiagnostic.h.
2395 class ddiag_iterator;
2396
2397 using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>;
2398
2399 inline ddiag_range ddiags() const;
2400
2401 // Low-level accessors
2402
2403 /// Mark that there are external lexical declarations that we need
2404 /// to include in our lookup table (and that are not available as external
2405 /// visible lookups). These extra lookup results will be found by walking
2406 /// the lexical declarations of this context. This should be used only if
2407 /// setHasExternalLexicalStorage() has been called on any decl context for
2408 /// which this is the primary context.
2409 void setMustBuildLookupTable() {
2410 assert(this == getPrimaryContext() &&((void)0)
2411 "should only be called on primary context")((void)0);
2412 DeclContextBits.HasLazyExternalLexicalLookups = true;
2413 }
2414
2415 /// Retrieve the internal representation of the lookup structure.
2416 /// This may omit some names if we are lazily building the structure.
2417 StoredDeclsMap *getLookupPtr() const { return LookupPtr; }
2418
2419 /// Ensure the lookup structure is fully-built and return it.
2420 StoredDeclsMap *buildLookup();
2421
2422 /// Whether this DeclContext has external storage containing
2423 /// additional declarations that are lexically in this context.
2424 bool hasExternalLexicalStorage() const {
2425 return DeclContextBits.ExternalLexicalStorage;
2426 }
2427
2428 /// State whether this DeclContext has external storage for
2429 /// declarations lexically in this context.
2430 void setHasExternalLexicalStorage(bool ES = true) const {
2431 DeclContextBits.ExternalLexicalStorage = ES;
2432 }
2433
2434 /// Whether this DeclContext has external storage containing
2435 /// additional declarations that are visible in this context.
2436 bool hasExternalVisibleStorage() const {
2437 return DeclContextBits.ExternalVisibleStorage;
2438 }
2439
2440 /// State whether this DeclContext has external storage for
2441 /// declarations visible in this context.
2442 void setHasExternalVisibleStorage(bool ES = true) const {
2443 DeclContextBits.ExternalVisibleStorage = ES;
2444 if (ES && LookupPtr)
2445 DeclContextBits.NeedToReconcileExternalVisibleStorage = true;
2446 }
2447
2448 /// Determine whether the given declaration is stored in the list of
2449 /// declarations lexically within this context.
2450 bool isDeclInLexicalTraversal(const Decl *D) const {
2451 return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl ||
2452 D == LastDecl);
2453 }
2454
2455 bool setUseQualifiedLookup(bool use = true) const {
2456 bool old_value = DeclContextBits.UseQualifiedLookup;
2457 DeclContextBits.UseQualifiedLookup = use;
2458 return old_value;
2459 }
2460
2461 bool shouldUseQualifiedLookup() const {
2462 return DeclContextBits.UseQualifiedLookup;
2463 }
2464
2465 static bool classof(const Decl *D);
2466 static bool classof(const DeclContext *D) { return true; }
2467
2468 void dumpDeclContext() const;
2469 void dumpLookups() const;
2470 void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false,
2471 bool Deserialize = false) const;
2472
2473private:
2474 /// Whether this declaration context has had externally visible
2475 /// storage added since the last lookup. In this case, \c LookupPtr's
2476 /// invariant may not hold and needs to be fixed before we perform
2477 /// another lookup.
2478 bool hasNeedToReconcileExternalVisibleStorage() const {
2479 return DeclContextBits.NeedToReconcileExternalVisibleStorage;
2480 }
2481
2482 /// State that this declaration context has had externally visible
2483 /// storage added since the last lookup. In this case, \c LookupPtr's
2484 /// invariant may not hold and needs to be fixed before we perform
2485 /// another lookup.
2486 void setNeedToReconcileExternalVisibleStorage(bool Need = true) const {
2487 DeclContextBits.NeedToReconcileExternalVisibleStorage = Need;
2488 }
2489
2490 /// If \c true, this context may have local lexical declarations
2491 /// that are missing from the lookup table.
2492 bool hasLazyLocalLexicalLookups() const {
2493 return DeclContextBits.HasLazyLocalLexicalLookups;
2494 }
2495
2496 /// If \c true, this context may have local lexical declarations
2497 /// that are missing from the lookup table.
2498 void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const {
2499 DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL;
2500 }
2501
2502 /// If \c true, the external source may have lexical declarations
2503 /// that are missing from the lookup table.
2504 bool hasLazyExternalLexicalLookups() const {
2505 return DeclContextBits.HasLazyExternalLexicalLookups;
2506 }
2507
2508 /// If \c true, the external source may have lexical declarations
2509 /// that are missing from the lookup table.
2510 void setHasLazyExternalLexicalLookups(bool HasLELL = true) const {
2511 DeclContextBits.HasLazyExternalLexicalLookups = HasLELL;
2512 }
2513
2514 void reconcileExternalVisibleStorage() const;
2515 bool LoadLexicalDeclsFromExternalStorage() const;
2516
2517 /// Makes a declaration visible within this context, but
2518 /// suppresses searches for external declarations with the same
2519 /// name.
2520 ///
2521 /// Analogous to makeDeclVisibleInContext, but for the exclusive
2522 /// use of addDeclInternal().
2523 void makeDeclVisibleInContextInternal(NamedDecl *D);
2524
2525 StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const;
2526
2527 void loadLazyLocalLexicalLookups();
2528 void buildLookupImpl(DeclContext *DCtx, bool Internal);
2529 void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
2530 bool Rediscoverable);
2531 void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal);
2532};
2533
2534inline bool Decl::isTemplateParameter() const {
2535 return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm ||
2536 getKind() == TemplateTemplateParm;
2537}
2538
2539// Specialization selected when ToTy is not a known subclass of DeclContext.
2540template <class ToTy,
2541 bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value>
2542struct cast_convert_decl_context {
2543 static const ToTy *doit(const DeclContext *Val) {
2544 return static_cast<const ToTy*>(Decl::castFromDeclContext(Val));
2545 }
2546
2547 static ToTy *doit(DeclContext *Val) {
2548 return static_cast<ToTy*>(Decl::castFromDeclContext(Val));
2549 }
2550};
2551
2552// Specialization selected when ToTy is a known subclass of DeclContext.
2553template <class ToTy>
2554struct cast_convert_decl_context<ToTy, true> {
2555 static const ToTy *doit(const DeclContext *Val) {
2556 return static_cast<const ToTy*>(Val);
2557 }
2558
2559 static ToTy *doit(DeclContext *Val) {
2560 return static_cast<ToTy*>(Val);
2561 }
2562};
2563
2564} // namespace clang
2565
2566namespace llvm {
2567
2568/// isa<T>(DeclContext*)
2569template <typename To>
2570struct isa_impl<To, ::clang::DeclContext> {
2571 static bool doit(const ::clang::DeclContext &Val) {
2572 return To::classofKind(Val.getDeclKind());
2573 }
2574};
2575
2576/// cast<T>(DeclContext*)
2577template<class ToTy>
2578struct cast_convert_val<ToTy,
2579 const ::clang::DeclContext,const ::clang::DeclContext> {
2580 static const ToTy &doit(const ::clang::DeclContext &Val) {
2581 return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
2582 }
2583};
2584
2585template<class ToTy>
2586struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
2587 static ToTy &doit(::clang::DeclContext &Val) {
2588 return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
2589 }
2590};
2591
2592template<class ToTy>
2593struct cast_convert_val<ToTy,
2594 const ::clang::DeclContext*, const ::clang::DeclContext*> {
2595 static const ToTy *doit(const ::clang::DeclContext *Val) {
2596 return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2597 }
2598};
2599
2600template<class ToTy>
2601struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
2602 static ToTy *doit(::clang::DeclContext *Val) {
2603 return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2604 }
2605};
2606
2607/// Implement cast_convert_val for Decl -> DeclContext conversions.
2608template<class FromTy>
2609struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
2610 static ::clang::DeclContext &doit(const FromTy &Val) {
2611 return *FromTy::castToDeclContext(&Val);
2612 }
2613};
2614
2615template<class FromTy>
2616struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
2617 static ::clang::DeclContext *doit(const FromTy *Val) {
2618 return FromTy::castToDeclContext(Val);
2619 }
2620};
2621
2622template<class FromTy>
2623struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
2624 static const ::clang::DeclContext &doit(const FromTy &Val) {
2625 return *FromTy::castToDeclContext(&Val);
2626 }
2627};
2628
2629template<class FromTy>
2630struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
2631 static const ::clang::DeclContext *doit(const FromTy *Val) {
2632 return FromTy::castToDeclContext(Val);
2633 }
2634};
2635
2636} // namespace llvm
2637
2638#endif // LLVM_CLANG_AST_DECLBASE_H