Bug Summary

File:src/gnu/usr.bin/clang/liblldbPluginTypeSystem/../../../llvm/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
Warning:line 5716, column 9
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
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)
1781 return false;
1782
1783 if (!record_decl->field_empty())
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);
1788 if (cxx_record_decl) {
1789 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1790 for (base_class = cxx_record_decl->bases_begin(),
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());
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)
1
Assuming 'type' is non-null
2
Taking false branch
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) {
3
Control jumps to 'case ObjCObjectPointer:' at line 5712
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 =
5
'objc_class_type' initialized to a null pointer value
5714 qual_type->getAs<clang::ObjCObjectPointerType>();
4
Assuming the object is not a 'ObjCObjectPointerType'
5715 const clang::ObjCInterfaceType *objc_interface_type =
5716 objc_class_type->getInterfaceType();
6
Called C++ object pointer is null
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