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