LLDB  mainline
TypeSystemClang.cpp
Go to the documentation of this file.
1 //===-- TypeSystemClang.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "TypeSystemClang.h"
10 
11 #include "llvm/Support/FormatAdapters.h"
12 #include "llvm/Support/FormatVariadic.h"
13 
14 #include <mutex>
15 #include <string>
16 #include <vector>
17 
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTImporter.h"
20 #include "clang/AST/Attr.h"
21 #include "clang/AST/CXXInheritance.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Mangle.h"
25 #include "clang/AST/RecordLayout.h"
26 #include "clang/AST/Type.h"
27 #include "clang/AST/VTableBuilder.h"
28 #include "clang/Basic/Builtins.h"
29 #include "clang/Basic/Diagnostic.h"
30 #include "clang/Basic/FileManager.h"
31 #include "clang/Basic/FileSystemOptions.h"
32 #include "clang/Basic/LangStandard.h"
33 #include "clang/Basic/SourceManager.h"
34 #include "clang/Basic/TargetInfo.h"
35 #include "clang/Basic/TargetOptions.h"
36 #include "clang/Frontend/FrontendOptions.h"
37 #include "clang/Lex/HeaderSearch.h"
38 #include "clang/Lex/HeaderSearchOptions.h"
39 #include "clang/Lex/ModuleMap.h"
40 #include "clang/Sema/Sema.h"
41 
42 #include "llvm/Support/Signals.h"
43 #include "llvm/Support/Threading.h"
44 
53 #include "lldb/Utility/ArchSpec.h"
54 #include "lldb/Utility/Flags.h"
55 
57 #include "lldb/Core/Module.h"
59 #include "lldb/Core/StreamFile.h"
62 #include "lldb/Symbol/ObjectFile.h"
63 #include "lldb/Symbol/SymbolFile.h"
65 #include "lldb/Target/Language.h"
66 #include "lldb/Target/Process.h"
67 #include "lldb/Target/Target.h"
70 #include "lldb/Utility/Log.h"
72 #include "lldb/Utility/Scalar.h"
73 
77 
78 #include <cstdio>
79 
80 #include <mutex>
81 
82 using namespace lldb;
83 using namespace lldb_private;
84 using namespace clang;
85 using llvm::StringSwitch;
86 
88 
89 namespace {
90 static void VerifyDecl(clang::Decl *decl) {
91  assert(decl && "VerifyDecl called with nullptr?");
92 #ifndef NDEBUG
93  // We don't care about the actual access value here but only want to trigger
94  // that Clang calls its internal Decl::AccessDeclContextCheck validation.
95  decl->getAccess();
96 #endif
97 }
98 
99 static inline bool
100 TypeSystemClangSupportsLanguage(lldb::LanguageType language) {
101  return language == eLanguageTypeUnknown || // Clang is the default type system
106  // Use Clang for Rust until there is a proper language plugin for it
107  language == eLanguageTypeRust ||
108  language == eLanguageTypeExtRenderScript ||
109  // Use Clang for D until there is a proper language plugin for it
110  language == eLanguageTypeD ||
111  // Open Dylan compiler debug info is designed to be Clang-compatible
112  language == eLanguageTypeDylan;
113 }
114 
115 // Checks whether m1 is an overload of m2 (as opposed to an override). This is
116 // called by addOverridesForMethod to distinguish overrides (which share a
117 // vtable entry) from overloads (which require distinct entries).
118 bool isOverload(clang::CXXMethodDecl *m1, clang::CXXMethodDecl *m2) {
119  // FIXME: This should detect covariant return types, but currently doesn't.
120  lldbassert(&m1->getASTContext() == &m2->getASTContext() &&
121  "Methods should have the same AST context");
122  clang::ASTContext &context = m1->getASTContext();
123 
124  const auto *m1Type = llvm::cast<clang::FunctionProtoType>(
125  context.getCanonicalType(m1->getType()));
126 
127  const auto *m2Type = llvm::cast<clang::FunctionProtoType>(
128  context.getCanonicalType(m2->getType()));
129 
130  auto compareArgTypes = [&context](const clang::QualType &m1p,
131  const clang::QualType &m2p) {
132  return context.hasSameType(m1p.getUnqualifiedType(),
133  m2p.getUnqualifiedType());
134  };
135 
136  // FIXME: In C++14 and later, we can just pass m2Type->param_type_end()
137  // as a fourth parameter to std::equal().
138  return (m1->getNumParams() != m2->getNumParams()) ||
139  !std::equal(m1Type->param_type_begin(), m1Type->param_type_end(),
140  m2Type->param_type_begin(), compareArgTypes);
141 }
142 
143 // If decl is a virtual method, walk the base classes looking for methods that
144 // decl overrides. This table of overridden methods is used by IRGen to
145 // determine the vtable layout for decl's parent class.
146 void addOverridesForMethod(clang::CXXMethodDecl *decl) {
147  if (!decl->isVirtual())
148  return;
149 
150  clang::CXXBasePaths paths;
151  llvm::SmallVector<clang::NamedDecl *, 4> decls;
152 
153  auto find_overridden_methods =
154  [&decls, decl](const clang::CXXBaseSpecifier *specifier,
155  clang::CXXBasePath &path) {
156  if (auto *base_record = llvm::dyn_cast<clang::CXXRecordDecl>(
157  specifier->getType()->getAs<clang::RecordType>()->getDecl())) {
158 
159  clang::DeclarationName name = decl->getDeclName();
160 
161  // If this is a destructor, check whether the base class destructor is
162  // virtual.
163  if (name.getNameKind() == clang::DeclarationName::CXXDestructorName)
164  if (auto *baseDtorDecl = base_record->getDestructor()) {
165  if (baseDtorDecl->isVirtual()) {
166  decls.push_back(baseDtorDecl);
167  return true;
168  } else
169  return false;
170  }
171 
172  // Otherwise, search for name in the base class.
173  for (path.Decls = base_record->lookup(name).begin();
174  path.Decls != path.Decls.end(); ++path.Decls) {
175  if (auto *method_decl =
176  llvm::dyn_cast<clang::CXXMethodDecl>(*path.Decls))
177  if (method_decl->isVirtual() && !isOverload(decl, method_decl)) {
178  decls.push_back(method_decl);
179  return true;
180  }
181  }
182  }
183 
184  return false;
185  };
186 
187  if (decl->getParent()->lookupInBases(find_overridden_methods, paths)) {
188  for (auto *overridden_decl : decls)
189  decl->addOverriddenMethod(
190  llvm::cast<clang::CXXMethodDecl>(overridden_decl));
191  }
192 }
193 }
194 
196  VTableContextBase &vtable_ctx,
197  ValueObject &valobj,
198  const ASTRecordLayout &record_layout) {
199  // Retrieve type info
200  CompilerType pointee_type;
201  CompilerType this_type(valobj.GetCompilerType());
202  uint32_t type_info = this_type.GetTypeInfo(&pointee_type);
203  if (!type_info)
204  return LLDB_INVALID_ADDRESS;
205 
206  // Check if it's a pointer or reference
207  bool ptr_or_ref = false;
208  if (type_info & (eTypeIsPointer | eTypeIsReference)) {
209  ptr_or_ref = true;
210  type_info = pointee_type.GetTypeInfo();
211  }
212 
213  // We process only C++ classes
214  const uint32_t cpp_class = eTypeIsClass | eTypeIsCPlusPlus;
215  if ((type_info & cpp_class) != cpp_class)
216  return LLDB_INVALID_ADDRESS;
217 
218  // Calculate offset to VTable pointer
219  lldb::offset_t vbtable_ptr_offset =
220  vtable_ctx.isMicrosoft() ? record_layout.getVBPtrOffset().getQuantity()
221  : 0;
222 
223  if (ptr_or_ref) {
224  // We have a pointer / ref to object, so read
225  // VTable pointer from process memory
226 
228  return LLDB_INVALID_ADDRESS;
229 
230  auto vbtable_ptr_addr = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
231  if (vbtable_ptr_addr == LLDB_INVALID_ADDRESS)
232  return LLDB_INVALID_ADDRESS;
233 
234  vbtable_ptr_addr += vbtable_ptr_offset;
235 
236  Status err;
237  return process.ReadPointerFromMemory(vbtable_ptr_addr, err);
238  }
239 
240  // We have an object already read from process memory,
241  // so just extract VTable pointer from it
242 
243  DataExtractor data;
244  Status err;
245  auto size = valobj.GetData(data, err);
246  if (err.Fail() || vbtable_ptr_offset + data.GetAddressByteSize() > size)
247  return LLDB_INVALID_ADDRESS;
248 
249  return data.GetAddress(&vbtable_ptr_offset);
250 }
251 
252 static int64_t ReadVBaseOffsetFromVTable(Process &process,
253  VTableContextBase &vtable_ctx,
254  lldb::addr_t vtable_ptr,
255  const CXXRecordDecl *cxx_record_decl,
256  const CXXRecordDecl *base_class_decl) {
257  if (vtable_ctx.isMicrosoft()) {
258  clang::MicrosoftVTableContext &msoft_vtable_ctx =
259  static_cast<clang::MicrosoftVTableContext &>(vtable_ctx);
260 
261  // Get the index into the virtual base table. The
262  // index is the index in uint32_t from vbtable_ptr
263  const unsigned vbtable_index =
264  msoft_vtable_ctx.getVBTableIndex(cxx_record_decl, base_class_decl);
265  const lldb::addr_t base_offset_addr = vtable_ptr + vbtable_index * 4;
266  Status err;
267  return process.ReadSignedIntegerFromMemory(base_offset_addr, 4, INT64_MAX,
268  err);
269  }
270 
271  clang::ItaniumVTableContext &itanium_vtable_ctx =
272  static_cast<clang::ItaniumVTableContext &>(vtable_ctx);
273 
274  clang::CharUnits base_offset_offset =
275  itanium_vtable_ctx.getVirtualBaseOffsetOffset(cxx_record_decl,
276  base_class_decl);
277  const lldb::addr_t base_offset_addr =
278  vtable_ptr + base_offset_offset.getQuantity();
279  const uint32_t base_offset_size = process.GetAddressByteSize();
280  Status err;
281  return process.ReadSignedIntegerFromMemory(base_offset_addr, base_offset_size,
282  INT64_MAX, err);
283 }
284 
285 static bool GetVBaseBitOffset(VTableContextBase &vtable_ctx,
286  ValueObject &valobj,
287  const ASTRecordLayout &record_layout,
288  const CXXRecordDecl *cxx_record_decl,
289  const CXXRecordDecl *base_class_decl,
290  int32_t &bit_offset) {
291  ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
292  Process *process = exe_ctx.GetProcessPtr();
293  if (!process)
294  return false;
295 
296  lldb::addr_t vtable_ptr =
297  GetVTableAddress(*process, vtable_ctx, valobj, record_layout);
298  if (vtable_ptr == LLDB_INVALID_ADDRESS)
299  return false;
300 
301  auto base_offset = ReadVBaseOffsetFromVTable(
302  *process, vtable_ctx, vtable_ptr, cxx_record_decl, base_class_decl);
303  if (base_offset == INT64_MAX)
304  return false;
305 
306  bit_offset = base_offset * 8;
307 
308  return true;
309 }
310 
313 
315  static ClangASTMap *g_map_ptr = nullptr;
316  static llvm::once_flag g_once_flag;
317  llvm::call_once(g_once_flag, []() {
318  g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins
319  });
320  return *g_map_ptr;
321 }
322 
323 TypePayloadClang::TypePayloadClang(OptionalClangModuleID owning_module,
324  bool is_complete_objc_class)
325  : m_payload(owning_module.GetValue()) {
326  SetIsCompleteObjCClass(is_complete_objc_class);
327 }
328 
330  assert(id.GetValue() < ObjCClassBit);
331  bool is_complete = IsCompleteObjCClass();
332  m_payload = id.GetValue();
333  SetIsCompleteObjCClass(is_complete);
334 }
335 
336 static void SetMemberOwningModule(clang::Decl *member,
337  const clang::Decl *parent) {
338  if (!member || !parent)
339  return;
340 
341  OptionalClangModuleID id(parent->getOwningModuleID());
342  if (!id.HasValue())
343  return;
344 
345  member->setFromASTFile();
346  member->setOwningModuleID(id.GetValue());
347  member->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
348  if (llvm::isa<clang::NamedDecl>(member))
349  if (auto *dc = llvm::dyn_cast<clang::DeclContext>(parent)) {
350  dc->setHasExternalVisibleStorage(true);
351  // This triggers ExternalASTSource::FindExternalVisibleDeclsByName() to be
352  // called when searching for members.
353  dc->setHasExternalLexicalStorage(true);
354  }
355 }
356 
358 
359 bool TypeSystemClang::IsOperator(llvm::StringRef name,
360  clang::OverloadedOperatorKind &op_kind) {
361  // All operators have to start with "operator".
362  if (!name.consume_front("operator"))
363  return false;
364 
365  // Remember if there was a space after "operator". This is necessary to
366  // check for collisions with strangely named functions like "operatorint()".
367  bool space_after_operator = name.consume_front(" ");
368 
369  op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
370  .Case("+", clang::OO_Plus)
371  .Case("+=", clang::OO_PlusEqual)
372  .Case("++", clang::OO_PlusPlus)
373  .Case("-", clang::OO_Minus)
374  .Case("-=", clang::OO_MinusEqual)
375  .Case("--", clang::OO_MinusMinus)
376  .Case("->", clang::OO_Arrow)
377  .Case("->*", clang::OO_ArrowStar)
378  .Case("*", clang::OO_Star)
379  .Case("*=", clang::OO_StarEqual)
380  .Case("/", clang::OO_Slash)
381  .Case("/=", clang::OO_SlashEqual)
382  .Case("%", clang::OO_Percent)
383  .Case("%=", clang::OO_PercentEqual)
384  .Case("^", clang::OO_Caret)
385  .Case("^=", clang::OO_CaretEqual)
386  .Case("&", clang::OO_Amp)
387  .Case("&=", clang::OO_AmpEqual)
388  .Case("&&", clang::OO_AmpAmp)
389  .Case("|", clang::OO_Pipe)
390  .Case("|=", clang::OO_PipeEqual)
391  .Case("||", clang::OO_PipePipe)
392  .Case("~", clang::OO_Tilde)
393  .Case("!", clang::OO_Exclaim)
394  .Case("!=", clang::OO_ExclaimEqual)
395  .Case("=", clang::OO_Equal)
396  .Case("==", clang::OO_EqualEqual)
397  .Case("<", clang::OO_Less)
398  .Case("<<", clang::OO_LessLess)
399  .Case("<<=", clang::OO_LessLessEqual)
400  .Case("<=", clang::OO_LessEqual)
401  .Case(">", clang::OO_Greater)
402  .Case(">>", clang::OO_GreaterGreater)
403  .Case(">>=", clang::OO_GreaterGreaterEqual)
404  .Case(">=", clang::OO_GreaterEqual)
405  .Case("()", clang::OO_Call)
406  .Case("[]", clang::OO_Subscript)
407  .Case(",", clang::OO_Comma)
408  .Default(clang::NUM_OVERLOADED_OPERATORS);
409 
410  // We found a fitting operator, so we can exit now.
411  if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
412  return true;
413 
414  // After the "operator " or "operator" part is something unknown. This means
415  // it's either one of the named operators (new/delete), a conversion operator
416  // (e.g. operator bool) or a function which name starts with "operator"
417  // (e.g. void operatorbool).
418 
419  // If it's a function that starts with operator it can't have a space after
420  // "operator" because identifiers can't contain spaces.
421  // E.g. "operator int" (conversion operator)
422  // vs. "operatorint" (function with colliding name).
423  if (!space_after_operator)
424  return false; // not an operator.
425 
426  // Now the operator is either one of the named operators or a conversion
427  // operator.
428  op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
429  .Case("new", clang::OO_New)
430  .Case("new[]", clang::OO_Array_New)
431  .Case("delete", clang::OO_Delete)
432  .Case("delete[]", clang::OO_Array_Delete)
433  // conversion operators hit this case.
434  .Default(clang::NUM_OVERLOADED_OPERATORS);
435 
436  return true;
437 }
438 
439 clang::AccessSpecifier
441  switch (access) {
442  default:
443  break;
444  case eAccessNone:
445  return AS_none;
446  case eAccessPublic:
447  return AS_public;
448  case eAccessPrivate:
449  return AS_private;
450  case eAccessProtected:
451  return AS_protected;
452  }
453  return AS_none;
454 }
455 
456 static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
457  // FIXME: Cleanup per-file based stuff.
458 
459  // Set some properties which depend solely on the input kind; it would be
460  // nice to move these to the language standard, and have the driver resolve
461  // the input kind + language standard.
462  if (IK.getLanguage() == clang::Language::Asm) {
463  Opts.AsmPreprocessor = 1;
464  } else if (IK.isObjectiveC()) {
465  Opts.ObjC = 1;
466  }
467 
468  LangStandard::Kind LangStd = LangStandard::lang_unspecified;
469 
470  if (LangStd == LangStandard::lang_unspecified) {
471  // Based on the base language, pick one.
472  switch (IK.getLanguage()) {
473  case clang::Language::Unknown:
474  case clang::Language::LLVM_IR:
475  case clang::Language::RenderScript:
476  llvm_unreachable("Invalid input kind!");
477  case clang::Language::OpenCL:
478  LangStd = LangStandard::lang_opencl10;
479  break;
480  case clang::Language::OpenCLCXX:
481  LangStd = LangStandard::lang_openclcpp10;
482  break;
483  case clang::Language::CUDA:
484  LangStd = LangStandard::lang_cuda;
485  break;
486  case clang::Language::Asm:
487  case clang::Language::C:
488  case clang::Language::ObjC:
489  LangStd = LangStandard::lang_gnu99;
490  break;
491  case clang::Language::CXX:
492  case clang::Language::ObjCXX:
493  LangStd = LangStandard::lang_gnucxx98;
494  break;
495  case clang::Language::HIP:
496  LangStd = LangStandard::lang_hip;
497  break;
498  }
499  }
500 
501  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
502  Opts.LineComment = Std.hasLineComments();
503  Opts.C99 = Std.isC99();
504  Opts.CPlusPlus = Std.isCPlusPlus();
505  Opts.CPlusPlus11 = Std.isCPlusPlus11();
506  Opts.Digraphs = Std.hasDigraphs();
507  Opts.GNUMode = Std.isGNUMode();
508  Opts.GNUInline = !Std.isC99();
509  Opts.HexFloats = Std.hasHexFloats();
510  Opts.ImplicitInt = Std.hasImplicitInt();
511 
512  Opts.WChar = true;
513 
514  // OpenCL has some additional defaults.
515  if (LangStd == LangStandard::lang_opencl10) {
516  Opts.OpenCL = 1;
517  Opts.AltiVec = 1;
518  Opts.CXXOperatorNames = 1;
519  Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::All);
520  }
521 
522  // OpenCL and C++ both have bool, true, false keywords.
523  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
524 
525  Opts.setValueVisibilityMode(DefaultVisibility);
526 
527  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs is
528  // specified, or -std is set to a conforming mode.
529  Opts.Trigraphs = !Opts.GNUMode;
530  Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault();
531  Opts.OptimizeSize = 0;
532 
533  // FIXME: Eliminate this dependency.
534  // unsigned Opt =
535  // Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
536  // Opts.Optimize = Opt != 0;
537  unsigned Opt = 0;
538 
539  // This is the __NO_INLINE__ define, which just depends on things like the
540  // optimization level and -fno-inline, not actually whether the backend has
541  // inlining enabled.
542  //
543  // FIXME: This is affected by other options (-fno-inline).
544  Opts.NoInlineDefine = !Opt;
545 
546  // This is needed to allocate the extra space for the owning module
547  // on each decl.
548  Opts.ModulesLocalVisibility = 1;
549 }
550 
551 TypeSystemClang::TypeSystemClang(llvm::StringRef name,
552  llvm::Triple target_triple) {
553  m_display_name = name.str();
554  if (!target_triple.str().empty())
555  SetTargetTriple(target_triple.str());
556  // The caller didn't pass an ASTContext so create a new one for this
557  // TypeSystemClang.
559 }
560 
561 TypeSystemClang::TypeSystemClang(llvm::StringRef name,
562  ASTContext &existing_ctxt) {
563  m_display_name = name.str();
564  SetTargetTriple(existing_ctxt.getTargetInfo().getTriple().str());
565 
566  m_ast_up.reset(&existing_ctxt);
567  GetASTMap().Insert(&existing_ctxt, this);
568 }
569 
570 // Destructor
572 
574  lldb_private::Module *module,
575  Target *target) {
576  if (!TypeSystemClangSupportsLanguage(language))
577  return lldb::TypeSystemSP();
578  ArchSpec arch;
579  if (module)
580  arch = module->GetArchitecture();
581  else if (target)
582  arch = target->GetArchitecture();
583 
584  if (!arch.IsValid())
585  return lldb::TypeSystemSP();
586 
587  llvm::Triple triple = arch.GetTriple();
588  // LLVM wants this to be set to iOS or MacOSX; if we're working on
589  // a bare-boards type image, change the triple for llvm's benefit.
590  if (triple.getVendor() == llvm::Triple::Apple &&
591  triple.getOS() == llvm::Triple::UnknownOS) {
592  if (triple.getArch() == llvm::Triple::arm ||
593  triple.getArch() == llvm::Triple::aarch64 ||
594  triple.getArch() == llvm::Triple::aarch64_32 ||
595  triple.getArch() == llvm::Triple::thumb) {
596  triple.setOS(llvm::Triple::IOS);
597  } else {
598  triple.setOS(llvm::Triple::MacOSX);
599  }
600  }
601 
602  if (module) {
603  std::string ast_name =
604  "ASTContext for '" + module->GetFileSpec().GetPath() + "'";
605  return std::make_shared<TypeSystemClang>(ast_name, triple);
606  } else if (target && target->IsValid())
607  return std::make_shared<ScratchTypeSystemClang>(*target, triple);
608  return lldb::TypeSystemSP();
609 }
610 
612  LanguageSet languages;
613  languages.Insert(lldb::eLanguageTypeC89);
614  languages.Insert(lldb::eLanguageTypeC);
615  languages.Insert(lldb::eLanguageTypeC11);
617  languages.Insert(lldb::eLanguageTypeC99);
618  languages.Insert(lldb::eLanguageTypeObjC);
622  languages.Insert(lldb::eLanguageTypeC11);
624  return languages;
625 }
626 
628  LanguageSet languages;
634  return languages;
635 }
636 
639  GetPluginNameStatic(), "clang base AST context plug-in", CreateInstance,
641 }
642 
645 }
646 
648  assert(m_ast_up);
649  GetASTMap().Erase(m_ast_up.get());
650  if (!m_ast_owned)
651  m_ast_up.release();
652 
653  m_builtins_up.reset();
654  m_selector_table_up.reset();
655  m_identifier_table_up.reset();
656  m_target_info_up.reset();
657  m_target_options_rp.reset();
658  m_diagnostics_engine_up.reset();
659  m_source_manager_up.reset();
660  m_language_options_up.reset();
661 }
662 
664  // Ensure that the new sema actually belongs to our ASTContext.
665  assert(s == nullptr || &s->getASTContext() == m_ast_up.get());
666  m_sema = s;
667 }
668 
670  return m_target_triple.c_str();
671 }
672 
673 void TypeSystemClang::SetTargetTriple(llvm::StringRef target_triple) {
674  m_target_triple = target_triple.str();
675 }
676 
678  llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_up) {
679  ASTContext &ast = getASTContext();
680  ast.getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
681  ast.setExternalSource(ast_source_up);
682 }
683 
685  assert(m_ast_up);
686  return *m_ast_up;
687 }
688 
689 class NullDiagnosticConsumer : public DiagnosticConsumer {
690 public:
693  }
694 
695  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
696  const clang::Diagnostic &info) override {
697  if (m_log) {
698  llvm::SmallVector<char, 32> diag_str(10);
699  info.FormatDiagnostic(diag_str);
700  diag_str.push_back('\0');
701  LLDB_LOGF(m_log, "Compiler diagnostic: %s\n", diag_str.data());
702  }
703  }
704 
705  DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
706  return new NullDiagnosticConsumer();
707  }
708 
709 private:
711 };
712 
714  assert(!m_ast_up);
715  m_ast_owned = true;
716 
717  m_language_options_up = std::make_unique<LangOptions>();
718  ParseLangArgs(*m_language_options_up, clang::Language::ObjCXX,
719  GetTargetTriple());
720 
722  std::make_unique<IdentifierTable>(*m_language_options_up, nullptr);
723  m_builtins_up = std::make_unique<Builtin::Context>();
724 
725  m_selector_table_up = std::make_unique<SelectorTable>();
726 
727  clang::FileSystemOptions file_system_options;
728  m_file_manager_up = std::make_unique<clang::FileManager>(
729  file_system_options, FileSystem::Instance().GetVirtualFileSystem());
730 
731  llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
733  std::make_unique<DiagnosticsEngine>(diag_id_sp, new DiagnosticOptions());
734 
735  m_source_manager_up = std::make_unique<clang::SourceManager>(
737  m_ast_up = std::make_unique<ASTContext>(
739  *m_selector_table_up, *m_builtins_up, TU_Complete);
740 
741  m_diagnostic_consumer_up = std::make_unique<NullDiagnosticConsumer>();
742  m_ast_up->getDiagnostics().setClient(m_diagnostic_consumer_up.get(), false);
743 
744  // This can be NULL if we don't know anything about the architecture or if
745  // the target for an architecture isn't enabled in the llvm/clang that we
746  // built
747  TargetInfo *target_info = getTargetInfo();
748  if (target_info)
749  m_ast_up->InitBuiltinTypes(*target_info);
750 
751  GetASTMap().Insert(m_ast_up.get(), this);
752 
753  llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up(
755  SetExternalSource(ast_source_up);
756 }
757 
759  TypeSystemClang *clang_ast = GetASTMap().Lookup(ast);
760  return clang_ast;
761 }
762 
763 clang::MangleContext *TypeSystemClang::getMangleContext() {
764  if (m_mangle_ctx_up == nullptr)
765  m_mangle_ctx_up.reset(getASTContext().createMangleContext());
766  return m_mangle_ctx_up.get();
767 }
768 
769 std::shared_ptr<clang::TargetOptions> &TypeSystemClang::getTargetOptions() {
770  if (m_target_options_rp == nullptr && !m_target_triple.empty()) {
771  m_target_options_rp = std::make_shared<clang::TargetOptions>();
772  if (m_target_options_rp != nullptr)
774  }
775  return m_target_options_rp;
776 }
777 
779  // target_triple should be something like "x86_64-apple-macosx"
780  if (m_target_info_up == nullptr && !m_target_triple.empty())
781  m_target_info_up.reset(TargetInfo::CreateTargetInfo(
782  getASTContext().getDiagnostics(), getTargetOptions()));
783  return m_target_info_up.get();
784 }
785 
786 #pragma mark Basic Types
787 
788 static inline bool QualTypeMatchesBitSize(const uint64_t bit_size,
789  ASTContext &ast, QualType qual_type) {
790  uint64_t qual_type_bit_size = ast.getTypeSize(qual_type);
791  return qual_type_bit_size == bit_size;
792 }
793 
796  size_t bit_size) {
797  ASTContext &ast = getASTContext();
798  switch (encoding) {
799  case eEncodingInvalid:
800  if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy))
801  return GetType(ast.VoidPtrTy);
802  break;
803 
804  case eEncodingUint:
805  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
806  return GetType(ast.UnsignedCharTy);
807  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
808  return GetType(ast.UnsignedShortTy);
809  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
810  return GetType(ast.UnsignedIntTy);
811  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
812  return GetType(ast.UnsignedLongTy);
813  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
814  return GetType(ast.UnsignedLongLongTy);
815  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
816  return GetType(ast.UnsignedInt128Ty);
817  break;
818 
819  case eEncodingSint:
820  if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
821  return GetType(ast.SignedCharTy);
822  if (QualTypeMatchesBitSize(bit_size, ast, ast.ShortTy))
823  return GetType(ast.ShortTy);
824  if (QualTypeMatchesBitSize(bit_size, ast, ast.IntTy))
825  return GetType(ast.IntTy);
826  if (QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
827  return GetType(ast.LongTy);
828  if (QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
829  return GetType(ast.LongLongTy);
830  if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
831  return GetType(ast.Int128Ty);
832  break;
833 
834  case eEncodingIEEE754:
835  if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
836  return GetType(ast.FloatTy);
837  if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
838  return GetType(ast.DoubleTy);
839  if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
840  return GetType(ast.LongDoubleTy);
841  if (QualTypeMatchesBitSize(bit_size, ast, ast.HalfTy))
842  return GetType(ast.HalfTy);
843  break;
844 
845  case eEncodingVector:
846  // Sanity check that bit_size is a multiple of 8's.
847  if (bit_size && !(bit_size & 0x7u))
848  return GetType(ast.getExtVectorType(ast.UnsignedCharTy, bit_size / 8));
849  break;
850  }
851 
852  return CompilerType();
853 }
854 
857  if (name) {
858  typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
859  static TypeNameToBasicTypeMap g_type_map;
860  static llvm::once_flag g_once_flag;
861  llvm::call_once(g_once_flag, []() {
862  // "void"
863  g_type_map.Append(ConstString("void"), eBasicTypeVoid);
864 
865  // "char"
866  g_type_map.Append(ConstString("char"), eBasicTypeChar);
867  g_type_map.Append(ConstString("signed char"), eBasicTypeSignedChar);
868  g_type_map.Append(ConstString("unsigned char"), eBasicTypeUnsignedChar);
869  g_type_map.Append(ConstString("wchar_t"), eBasicTypeWChar);
870  g_type_map.Append(ConstString("signed wchar_t"), eBasicTypeSignedWChar);
871  g_type_map.Append(ConstString("unsigned wchar_t"),
873  // "short"
874  g_type_map.Append(ConstString("short"), eBasicTypeShort);
875  g_type_map.Append(ConstString("short int"), eBasicTypeShort);
876  g_type_map.Append(ConstString("unsigned short"), eBasicTypeUnsignedShort);
877  g_type_map.Append(ConstString("unsigned short int"),
879 
880  // "int"
881  g_type_map.Append(ConstString("int"), eBasicTypeInt);
882  g_type_map.Append(ConstString("signed int"), eBasicTypeInt);
883  g_type_map.Append(ConstString("unsigned int"), eBasicTypeUnsignedInt);
884  g_type_map.Append(ConstString("unsigned"), eBasicTypeUnsignedInt);
885 
886  // "long"
887  g_type_map.Append(ConstString("long"), eBasicTypeLong);
888  g_type_map.Append(ConstString("long int"), eBasicTypeLong);
889  g_type_map.Append(ConstString("unsigned long"), eBasicTypeUnsignedLong);
890  g_type_map.Append(ConstString("unsigned long int"),
892 
893  // "long long"
894  g_type_map.Append(ConstString("long long"), eBasicTypeLongLong);
895  g_type_map.Append(ConstString("long long int"), eBasicTypeLongLong);
896  g_type_map.Append(ConstString("unsigned long long"),
898  g_type_map.Append(ConstString("unsigned long long int"),
900 
901  // "int128"
902  g_type_map.Append(ConstString("__int128_t"), eBasicTypeInt128);
903  g_type_map.Append(ConstString("__uint128_t"), eBasicTypeUnsignedInt128);
904 
905  // Miscellaneous
906  g_type_map.Append(ConstString("bool"), eBasicTypeBool);
907  g_type_map.Append(ConstString("float"), eBasicTypeFloat);
908  g_type_map.Append(ConstString("double"), eBasicTypeDouble);
909  g_type_map.Append(ConstString("long double"), eBasicTypeLongDouble);
910  g_type_map.Append(ConstString("id"), eBasicTypeObjCID);
911  g_type_map.Append(ConstString("SEL"), eBasicTypeObjCSel);
912  g_type_map.Append(ConstString("nullptr"), eBasicTypeNullPtr);
913  g_type_map.Sort();
914  });
915 
916  return g_type_map.Find(name, eBasicTypeInvalid);
917  }
918  return eBasicTypeInvalid;
919 }
920 
922  if (m_pointer_byte_size == 0)
923  if (auto size = GetBasicType(lldb::eBasicTypeVoid)
924  .GetPointerType()
925  .GetByteSize(nullptr))
926  m_pointer_byte_size = *size;
927  return m_pointer_byte_size;
928 }
929 
931  clang::ASTContext &ast = getASTContext();
932 
933  lldb::opaque_compiler_type_t clang_type =
934  GetOpaqueCompilerType(&ast, basic_type);
935 
936  if (clang_type)
937  return CompilerType(this, clang_type);
938  return CompilerType();
939 }
940 
942  llvm::StringRef type_name, uint32_t dw_ate, uint32_t bit_size) {
943  ASTContext &ast = getASTContext();
944 
945  switch (dw_ate) {
946  default:
947  break;
948 
949  case DW_ATE_address:
950  if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy))
951  return GetType(ast.VoidPtrTy);
952  break;
953 
954  case DW_ATE_boolean:
955  if (QualTypeMatchesBitSize(bit_size, ast, ast.BoolTy))
956  return GetType(ast.BoolTy);
957  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
958  return GetType(ast.UnsignedCharTy);
959  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
960  return GetType(ast.UnsignedShortTy);
961  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
962  return GetType(ast.UnsignedIntTy);
963  break;
964 
965  case DW_ATE_lo_user:
966  // This has been seen to mean DW_AT_complex_integer
967  if (type_name.contains("complex")) {
968  CompilerType complex_int_clang_type =
969  GetBuiltinTypeForDWARFEncodingAndBitSize("int", DW_ATE_signed,
970  bit_size / 2);
971  return GetType(
972  ast.getComplexType(ClangUtil::GetQualType(complex_int_clang_type)));
973  }
974  break;
975 
976  case DW_ATE_complex_float: {
977  CanQualType FloatComplexTy = ast.getComplexType(ast.FloatTy);
978  if (QualTypeMatchesBitSize(bit_size, ast, FloatComplexTy))
979  return GetType(FloatComplexTy);
980 
981  CanQualType DoubleComplexTy = ast.getComplexType(ast.DoubleTy);
982  if (QualTypeMatchesBitSize(bit_size, ast, DoubleComplexTy))
983  return GetType(DoubleComplexTy);
984 
985  CanQualType LongDoubleComplexTy = ast.getComplexType(ast.LongDoubleTy);
986  if (QualTypeMatchesBitSize(bit_size, ast, LongDoubleComplexTy))
987  return GetType(LongDoubleComplexTy);
988 
989  CompilerType complex_float_clang_type =
990  GetBuiltinTypeForDWARFEncodingAndBitSize("float", DW_ATE_float,
991  bit_size / 2);
992  return GetType(
993  ast.getComplexType(ClangUtil::GetQualType(complex_float_clang_type)));
994  }
995 
996  case DW_ATE_float:
997  if (type_name == "float" &&
998  QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
999  return GetType(ast.FloatTy);
1000  if (type_name == "double" &&
1001  QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
1002  return GetType(ast.DoubleTy);
1003  if (type_name == "long double" &&
1004  QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
1005  return GetType(ast.LongDoubleTy);
1006  // Fall back to not requiring a name match
1007  if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
1008  return GetType(ast.FloatTy);
1009  if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
1010  return GetType(ast.DoubleTy);
1011  if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
1012  return GetType(ast.LongDoubleTy);
1013  if (QualTypeMatchesBitSize(bit_size, ast, ast.HalfTy))
1014  return GetType(ast.HalfTy);
1015  break;
1016 
1017  case DW_ATE_signed:
1018  if (!type_name.empty()) {
1019  if (type_name == "wchar_t" &&
1020  QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy) &&
1021  (getTargetInfo() &&
1022  TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
1023  return GetType(ast.WCharTy);
1024  if (type_name == "void" &&
1025  QualTypeMatchesBitSize(bit_size, ast, ast.VoidTy))
1026  return GetType(ast.VoidTy);
1027  if (type_name.contains("long long") &&
1028  QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
1029  return GetType(ast.LongLongTy);
1030  if (type_name.contains("long") &&
1031  QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
1032  return GetType(ast.LongTy);
1033  if (type_name.contains("short") &&
1034  QualTypeMatchesBitSize(bit_size, ast, ast.ShortTy))
1035  return GetType(ast.ShortTy);
1036  if (type_name.contains("char")) {
1037  if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1038  return GetType(ast.CharTy);
1039  if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
1040  return GetType(ast.SignedCharTy);
1041  }
1042  if (type_name.contains("int")) {
1043  if (QualTypeMatchesBitSize(bit_size, ast, ast.IntTy))
1044  return GetType(ast.IntTy);
1045  if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
1046  return GetType(ast.Int128Ty);
1047  }
1048  }
1049  // We weren't able to match up a type name, just search by size
1050  if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1051  return GetType(ast.CharTy);
1052  if (QualTypeMatchesBitSize(bit_size, ast, ast.ShortTy))
1053  return GetType(ast.ShortTy);
1054  if (QualTypeMatchesBitSize(bit_size, ast, ast.IntTy))
1055  return GetType(ast.IntTy);
1056  if (QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
1057  return GetType(ast.LongTy);
1058  if (QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
1059  return GetType(ast.LongLongTy);
1060  if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
1061  return GetType(ast.Int128Ty);
1062  break;
1063 
1064  case DW_ATE_signed_char:
1065  if (ast.getLangOpts().CharIsSigned && type_name == "char") {
1066  if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1067  return GetType(ast.CharTy);
1068  }
1069  if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
1070  return GetType(ast.SignedCharTy);
1071  break;
1072 
1073  case DW_ATE_unsigned:
1074  if (!type_name.empty()) {
1075  if (type_name == "wchar_t") {
1076  if (QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy)) {
1077  if (!(getTargetInfo() &&
1078  TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
1079  return GetType(ast.WCharTy);
1080  }
1081  }
1082  if (type_name.contains("long long")) {
1083  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
1084  return GetType(ast.UnsignedLongLongTy);
1085  } else if (type_name.contains("long")) {
1086  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
1087  return GetType(ast.UnsignedLongTy);
1088  } else if (type_name.contains("short")) {
1089  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
1090  return GetType(ast.UnsignedShortTy);
1091  } else if (type_name.contains("char")) {
1092  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
1093  return GetType(ast.UnsignedCharTy);
1094  } else if (type_name.contains("int")) {
1095  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
1096  return GetType(ast.UnsignedIntTy);
1097  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
1098  return GetType(ast.UnsignedInt128Ty);
1099  }
1100  }
1101  // We weren't able to match up a type name, just search by size
1102  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
1103  return GetType(ast.UnsignedCharTy);
1104  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
1105  return GetType(ast.UnsignedShortTy);
1106  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
1107  return GetType(ast.UnsignedIntTy);
1108  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
1109  return GetType(ast.UnsignedLongTy);
1110  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
1111  return GetType(ast.UnsignedLongLongTy);
1112  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
1113  return GetType(ast.UnsignedInt128Ty);
1114  break;
1115 
1116  case DW_ATE_unsigned_char:
1117  if (!ast.getLangOpts().CharIsSigned && type_name == "char") {
1118  if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
1119  return GetType(ast.CharTy);
1120  }
1121  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
1122  return GetType(ast.UnsignedCharTy);
1123  if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
1124  return GetType(ast.UnsignedShortTy);
1125  break;
1126 
1127  case DW_ATE_imaginary_float:
1128  break;
1129 
1130  case DW_ATE_UTF:
1131  switch (bit_size) {
1132  case 8:
1133  return GetType(ast.Char8Ty);
1134  case 16:
1135  return GetType(ast.Char16Ty);
1136  case 32:
1137  return GetType(ast.Char32Ty);
1138  default:
1139  if (!type_name.empty()) {
1140  if (type_name == "char16_t")
1141  return GetType(ast.Char16Ty);
1142  if (type_name == "char32_t")
1143  return GetType(ast.Char32Ty);
1144  if (type_name == "char8_t")
1145  return GetType(ast.Char8Ty);
1146  }
1147  }
1148  break;
1149  }
1150 
1152  LLDB_LOG(log,
1153  "error: need to add support for DW_TAG_base_type '{0}' "
1154  "encoded with DW_ATE = {1:x}, bit_size = {2}",
1155  type_name, dw_ate, bit_size);
1156  return CompilerType();
1157 }
1158 
1160  ASTContext &ast = getASTContext();
1161  QualType char_type(ast.CharTy);
1162 
1163  if (is_const)
1164  char_type.addConst();
1165 
1166  return GetType(ast.getPointerType(char_type));
1167 }
1168 
1170  bool ignore_qualifiers) {
1171  TypeSystemClang *ast =
1172  llvm::dyn_cast_or_null<TypeSystemClang>(type1.GetTypeSystem());
1173  if (!ast || ast != type2.GetTypeSystem())
1174  return false;
1175 
1176  if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
1177  return true;
1178 
1179  QualType type1_qual = ClangUtil::GetQualType(type1);
1180  QualType type2_qual = ClangUtil::GetQualType(type2);
1181 
1182  if (ignore_qualifiers) {
1183  type1_qual = type1_qual.getUnqualifiedType();
1184  type2_qual = type2_qual.getUnqualifiedType();
1185  }
1186 
1187  return ast->getASTContext().hasSameType(type1_qual, type2_qual);
1188 }
1189 
1191  if (!opaque_decl)
1192  return CompilerType();
1193 
1194  clang::Decl *decl = static_cast<clang::Decl *>(opaque_decl);
1195  if (auto *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl))
1196  return GetTypeForDecl(named_decl);
1197  return CompilerType();
1198 }
1199 
1201  // Check that the DeclContext actually belongs to this ASTContext.
1202  assert(&ctx->getParentASTContext() == &getASTContext());
1203  return CompilerDeclContext(this, ctx);
1204 }
1205 
1207  if (clang::ObjCInterfaceDecl *interface_decl =
1208  llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
1209  return GetTypeForDecl(interface_decl);
1210  if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
1211  return GetTypeForDecl(tag_decl);
1212  return CompilerType();
1213 }
1214 
1216  return GetType(getASTContext().getTagDeclType(decl));
1217 }
1218 
1219 CompilerType TypeSystemClang::GetTypeForDecl(ObjCInterfaceDecl *decl) {
1220  return GetType(getASTContext().getObjCInterfaceType(decl));
1221 }
1222 
1223 #pragma mark Structure, Unions, Classes
1224 
1225 void TypeSystemClang::SetOwningModule(clang::Decl *decl,
1226  OptionalClangModuleID owning_module) {
1227  if (!decl || !owning_module.HasValue())
1228  return;
1229 
1230  decl->setFromASTFile();
1231  decl->setOwningModuleID(owning_module.GetValue());
1232  decl->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
1233 }
1234 
1237  OptionalClangModuleID parent,
1238  bool is_framework, bool is_explicit) {
1239  // Get the external AST source which holds the modules.
1240  auto *ast_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>(
1241  getASTContext().getExternalSource());
1242  assert(ast_source && "external ast source was lost");
1243  if (!ast_source)
1244  return {};
1245 
1246  // Lazily initialize the module map.
1247  if (!m_header_search_up) {
1248  auto HSOpts = std::make_shared<clang::HeaderSearchOptions>();
1249  m_header_search_up = std::make_unique<clang::HeaderSearch>(
1252  m_module_map_up = std::make_unique<clang::ModuleMap>(
1255  }
1256 
1257  // Get or create the module context.
1258  bool created;
1259  clang::Module *module;
1260  auto parent_desc = ast_source->getSourceDescriptor(parent.GetValue());
1261  std::tie(module, created) = m_module_map_up->findOrCreateModule(
1262  name, parent_desc ? parent_desc->getModuleOrNull() : nullptr,
1263  is_framework, is_explicit);
1264  if (!created)
1265  return ast_source->GetIDForModule(module);
1266 
1267  return ast_source->RegisterModule(module);
1268 }
1269 
1271  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1272  AccessType access_type, llvm::StringRef name, int kind,
1273  LanguageType language, ClangASTMetadata *metadata, bool exports_symbols) {
1274  ASTContext &ast = getASTContext();
1275 
1276  if (decl_ctx == nullptr)
1277  decl_ctx = ast.getTranslationUnitDecl();
1278 
1279  if (language == eLanguageTypeObjC ||
1280  language == eLanguageTypeObjC_plus_plus) {
1281  bool isForwardDecl = true;
1282  bool isInternal = false;
1283  return CreateObjCClass(name, decl_ctx, owning_module, isForwardDecl,
1284  isInternal, metadata);
1285  }
1286 
1287  // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1288  // we will need to update this code. I was told to currently always use the
1289  // CXXRecordDecl class since we often don't know from debug information if
1290  // something is struct or a class, so we default to always use the more
1291  // complete definition just in case.
1292 
1293  bool has_name = !name.empty();
1294  CXXRecordDecl *decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1295  decl->setTagKind(static_cast<TagDecl::TagKind>(kind));
1296  decl->setDeclContext(decl_ctx);
1297  if (has_name)
1298  decl->setDeclName(&ast.Idents.get(name));
1299  SetOwningModule(decl, owning_module);
1300 
1301  if (!has_name) {
1302  // In C++ a lambda is also represented as an unnamed class. This is
1303  // different from an *anonymous class* that the user wrote:
1304  //
1305  // struct A {
1306  // // anonymous class (GNU/MSVC extension)
1307  // struct {
1308  // int x;
1309  // };
1310  // // unnamed class within a class
1311  // struct {
1312  // int y;
1313  // } B;
1314  // };
1315  //
1316  // void f() {
1317  // // unammed class outside of a class
1318  // struct {
1319  // int z;
1320  // } C;
1321  // }
1322  //
1323  // Anonymous classes is a GNU/MSVC extension that clang supports. It
1324  // requires the anonymous class be embedded within a class. So the new
1325  // heuristic verifies this condition.
1326  if (isa<CXXRecordDecl>(decl_ctx) && exports_symbols)
1327  decl->setAnonymousStructOrUnion(true);
1328  }
1329 
1330  if (metadata)
1331  SetMetadata(decl, *metadata);
1332 
1333  if (access_type != eAccessNone)
1334  decl->setAccess(ConvertAccessTypeToAccessSpecifier(access_type));
1335 
1336  if (decl_ctx)
1337  decl_ctx->addDecl(decl);
1338 
1339  return GetType(ast.getTagDeclType(decl));
1340 }
1341 
1342 namespace {
1343 /// Returns true iff the given TemplateArgument should be represented as an
1344 /// NonTypeTemplateParmDecl in the AST.
1345 bool IsValueParam(const clang::TemplateArgument &argument) {
1346  return argument.getKind() == TemplateArgument::Integral;
1347 }
1348 
1349 void AddAccessSpecifierDecl(clang::CXXRecordDecl *cxx_record_decl,
1350  ASTContext &ct,
1351  clang::AccessSpecifier previous_access,
1352  clang::AccessSpecifier access_specifier) {
1353  if (!cxx_record_decl->isClass() && !cxx_record_decl->isStruct())
1354  return;
1355  if (previous_access != access_specifier) {
1356  // For struct, don't add AS_public if it's the first AccessSpecDecl.
1357  // For class, don't add AS_private if it's the first AccessSpecDecl.
1358  if ((cxx_record_decl->isStruct() &&
1359  previous_access == clang::AccessSpecifier::AS_none &&
1360  access_specifier == clang::AccessSpecifier::AS_public) ||
1361  (cxx_record_decl->isClass() &&
1362  previous_access == clang::AccessSpecifier::AS_none &&
1363  access_specifier == clang::AccessSpecifier::AS_private)) {
1364  return;
1365  }
1366  cxx_record_decl->addDecl(
1367  AccessSpecDecl::Create(ct, access_specifier, cxx_record_decl,
1368  SourceLocation(), SourceLocation()));
1369  }
1370 }
1371 } // namespace
1372 
1373 static TemplateParameterList *CreateTemplateParameterList(
1374  ASTContext &ast,
1375  const TypeSystemClang::TemplateParameterInfos &template_param_infos,
1376  llvm::SmallVector<NamedDecl *, 8> &template_param_decls) {
1377  const bool parameter_pack = false;
1378  const bool is_typename = false;
1379  const unsigned depth = 0;
1380  const size_t num_template_params = template_param_infos.args.size();
1381  DeclContext *const decl_context =
1382  ast.getTranslationUnitDecl(); // Is this the right decl context?,
1383  for (size_t i = 0; i < num_template_params; ++i) {
1384  const char *name = template_param_infos.names[i];
1385 
1386  IdentifierInfo *identifier_info = nullptr;
1387  if (name && name[0])
1388  identifier_info = &ast.Idents.get(name);
1389  if (IsValueParam(template_param_infos.args[i])) {
1390  QualType template_param_type =
1391  template_param_infos.args[i].getIntegralType();
1392  template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1393  ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1394  identifier_info, template_param_type, parameter_pack,
1395  ast.getTrivialTypeSourceInfo(template_param_type)));
1396  } else {
1397  template_param_decls.push_back(TemplateTypeParmDecl::Create(
1398  ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1399  identifier_info, is_typename, parameter_pack));
1400  }
1401  }
1402 
1403  if (template_param_infos.packed_args) {
1404  IdentifierInfo *identifier_info = nullptr;
1405  if (template_param_infos.pack_name && template_param_infos.pack_name[0])
1406  identifier_info = &ast.Idents.get(template_param_infos.pack_name);
1407  const bool parameter_pack_true = true;
1408 
1409  if (!template_param_infos.packed_args->args.empty() &&
1410  IsValueParam(template_param_infos.packed_args->args[0])) {
1411  QualType template_param_type =
1412  template_param_infos.packed_args->args[0].getIntegralType();
1413  template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1414  ast, decl_context, SourceLocation(), SourceLocation(), depth,
1415  num_template_params, identifier_info, template_param_type,
1416  parameter_pack_true,
1417  ast.getTrivialTypeSourceInfo(template_param_type)));
1418  } else {
1419  template_param_decls.push_back(TemplateTypeParmDecl::Create(
1420  ast, decl_context, SourceLocation(), SourceLocation(), depth,
1421  num_template_params, identifier_info, is_typename,
1422  parameter_pack_true));
1423  }
1424  }
1425  clang::Expr *const requires_clause = nullptr; // TODO: Concepts
1426  TemplateParameterList *template_param_list = TemplateParameterList::Create(
1427  ast, SourceLocation(), SourceLocation(), template_param_decls,
1428  SourceLocation(), requires_clause);
1429  return template_param_list;
1430 }
1431 
1432 clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl(
1433  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1434  clang::FunctionDecl *func_decl,
1435  const TemplateParameterInfos &template_param_infos) {
1436  // /// Create a function template node.
1437  ASTContext &ast = getASTContext();
1438 
1439  llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1440  TemplateParameterList *template_param_list = CreateTemplateParameterList(
1441  ast, template_param_infos, template_param_decls);
1442  FunctionTemplateDecl *func_tmpl_decl =
1443  FunctionTemplateDecl::CreateDeserialized(ast, 0);
1444  func_tmpl_decl->setDeclContext(decl_ctx);
1445  func_tmpl_decl->setLocation(func_decl->getLocation());
1446  func_tmpl_decl->setDeclName(func_decl->getDeclName());
1447  func_tmpl_decl->init(func_decl, template_param_list);
1448  SetOwningModule(func_tmpl_decl, owning_module);
1449 
1450  for (size_t i = 0, template_param_decl_count = template_param_decls.size();
1451  i < template_param_decl_count; ++i) {
1452  // TODO: verify which decl context we should put template_param_decls into..
1453  template_param_decls[i]->setDeclContext(func_decl);
1454  }
1455  // Function templates inside a record need to have an access specifier.
1456  // It doesn't matter what access specifier we give the template as LLDB
1457  // anyway allows accessing everything inside a record.
1458  if (decl_ctx->isRecord())
1459  func_tmpl_decl->setAccess(clang::AccessSpecifier::AS_public);
1460 
1461  return func_tmpl_decl;
1462 }
1463 
1465  FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
1466  const TemplateParameterInfos &infos) {
1467  TemplateArgumentList *template_args_ptr =
1468  TemplateArgumentList::CreateCopy(func_decl->getASTContext(), infos.args);
1469 
1470  func_decl->setFunctionTemplateSpecialization(func_tmpl_decl,
1471  template_args_ptr, nullptr);
1472 }
1473 
1474 /// Returns true if the given template parameter can represent the given value.
1475 /// For example, `typename T` can represent `int` but not integral values such
1476 /// as `int I = 3`.
1477 static bool TemplateParameterAllowsValue(NamedDecl *param,
1478  const TemplateArgument &value) {
1479  if (llvm::isa<TemplateTypeParmDecl>(param)) {
1480  // Compare the argument kind, i.e. ensure that <typename> != <int>.
1481  if (value.getKind() != TemplateArgument::Type)
1482  return false;
1483  } else if (auto *type_param =
1484  llvm::dyn_cast<NonTypeTemplateParmDecl>(param)) {
1485  // Compare the argument kind, i.e. ensure that <typename> != <int>.
1486  if (!IsValueParam(value))
1487  return false;
1488  // Compare the integral type, i.e. ensure that <int> != <char>.
1489  if (type_param->getType() != value.getIntegralType())
1490  return false;
1491  } else {
1492  // There is no way to create other parameter decls at the moment, so we
1493  // can't reach this case during normal LLDB usage. Log that this happened
1494  // and assert.
1496  LLDB_LOG(log,
1497  "Don't know how to compare template parameter to passed"
1498  " value. Decl kind of parameter is: {0}",
1499  param->getDeclKindName());
1500  lldbassert(false && "Can't compare this TemplateParmDecl subclass");
1501  // In release builds just fall back to marking the parameter as not
1502  // accepting the value so that we don't try to fit an instantiation to a
1503  // template that doesn't fit. E.g., avoid that `S<1>` is being connected to
1504  // `template<typename T> struct S;`.
1505  return false;
1506  }
1507  return true;
1508 }
1509 
1510 /// Returns true if the given class template declaration could produce an
1511 /// instantiation with the specified values.
1512 /// For example, `<typename T>` allows the arguments `float`, but not for
1513 /// example `bool, float` or `3` (as an integer parameter value).
1515  ClassTemplateDecl *class_template_decl,
1516  const TypeSystemClang::TemplateParameterInfos &instantiation_values) {
1517 
1518  TemplateParameterList &params = *class_template_decl->getTemplateParameters();
1519 
1520  // Save some work by iterating only once over the found parameters and
1521  // calculate the information related to parameter packs.
1522 
1523  // Contains the first pack parameter (or non if there are none).
1524  llvm::Optional<NamedDecl *> pack_parameter;
1525  // Contains the number of non-pack parameters.
1526  size_t non_pack_params = params.size();
1527  for (size_t i = 0; i < params.size(); ++i) {
1528  NamedDecl *param = params.getParam(i);
1529  if (param->isParameterPack()) {
1530  pack_parameter = param;
1531  non_pack_params = i;
1532  break;
1533  }
1534  }
1535 
1536  // The found template needs to have compatible non-pack template arguments.
1537  // E.g., ensure that <typename, typename> != <typename>.
1538  // The pack parameters are compared later.
1539  if (non_pack_params != instantiation_values.args.size())
1540  return false;
1541 
1542  // Ensure that <typename...> != <typename>.
1543  if (pack_parameter.hasValue() != instantiation_values.hasParameterPack())
1544  return false;
1545 
1546  // Compare the first pack parameter that was found with the first pack
1547  // parameter value. The special case of having an empty parameter pack value
1548  // always fits to a pack parameter.
1549  // E.g., ensure that <int...> != <typename...>.
1550  if (pack_parameter && !instantiation_values.packed_args->args.empty() &&
1552  *pack_parameter, instantiation_values.packed_args->args.front()))
1553  return false;
1554 
1555  // Compare all the non-pack parameters now.
1556  // E.g., ensure that <int> != <long>.
1557  for (const auto pair : llvm::zip_first(instantiation_values.args, params)) {
1558  const TemplateArgument &passed_arg = std::get<0>(pair);
1559  NamedDecl *found_param = std::get<1>(pair);
1560  if (!TemplateParameterAllowsValue(found_param, passed_arg))
1561  return false;
1562  }
1563 
1564  return class_template_decl;
1565 }
1566 
1568  DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1569  lldb::AccessType access_type, llvm::StringRef class_name, int kind,
1570  const TemplateParameterInfos &template_param_infos) {
1571  ASTContext &ast = getASTContext();
1572 
1573  ClassTemplateDecl *class_template_decl = nullptr;
1574  if (decl_ctx == nullptr)
1575  decl_ctx = ast.getTranslationUnitDecl();
1576 
1577  IdentifierInfo &identifier_info = ast.Idents.get(class_name);
1578  DeclarationName decl_name(&identifier_info);
1579 
1580  // Search the AST for an existing ClassTemplateDecl that could be reused.
1581  clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1582  for (NamedDecl *decl : result) {
1583  class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1584  if (!class_template_decl)
1585  continue;
1586  // The class template has to be able to represents the instantiation
1587  // values we received. Without this we might end up putting an instantiation
1588  // with arguments such as <int, int> to a template such as:
1589  // template<typename T> struct S;
1590  // Connecting the instantiation to an incompatible template could cause
1591  // problems later on.
1592  if (!ClassTemplateAllowsToInstantiationArgs(class_template_decl,
1593  template_param_infos))
1594  continue;
1595  return class_template_decl;
1596  }
1597 
1598  llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1599 
1600  TemplateParameterList *template_param_list = CreateTemplateParameterList(
1601  ast, template_param_infos, template_param_decls);
1602 
1603  CXXRecordDecl *template_cxx_decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1604  template_cxx_decl->setTagKind(static_cast<TagDecl::TagKind>(kind));
1605  // What decl context do we use here? TU? The actual decl context?
1606  template_cxx_decl->setDeclContext(decl_ctx);
1607  template_cxx_decl->setDeclName(decl_name);
1608  SetOwningModule(template_cxx_decl, owning_module);
1609 
1610  for (size_t i = 0, template_param_decl_count = template_param_decls.size();
1611  i < template_param_decl_count; ++i) {
1612  template_param_decls[i]->setDeclContext(template_cxx_decl);
1613  }
1614 
1615  // With templated classes, we say that a class is templated with
1616  // specializations, but that the bare class has no functions.
1617  // template_cxx_decl->startDefinition();
1618  // template_cxx_decl->completeDefinition();
1619 
1620  class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0);
1621  // What decl context do we use here? TU? The actual decl context?
1622  class_template_decl->setDeclContext(decl_ctx);
1623  class_template_decl->setDeclName(decl_name);
1624  class_template_decl->init(template_cxx_decl, template_param_list);
1625  template_cxx_decl->setDescribedClassTemplate(class_template_decl);
1626  SetOwningModule(class_template_decl, owning_module);
1627 
1628  if (access_type != eAccessNone)
1629  class_template_decl->setAccess(
1630  ConvertAccessTypeToAccessSpecifier(access_type));
1631 
1632  decl_ctx->addDecl(class_template_decl);
1633 
1634  VerifyDecl(class_template_decl);
1635 
1636  return class_template_decl;
1637 }
1638 
1639 TemplateTemplateParmDecl *
1641  ASTContext &ast = getASTContext();
1642 
1643  auto *decl_ctx = ast.getTranslationUnitDecl();
1644 
1645  IdentifierInfo &identifier_info = ast.Idents.get(template_name);
1646  llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1647 
1648  TypeSystemClang::TemplateParameterInfos template_param_infos;
1649  TemplateParameterList *template_param_list = CreateTemplateParameterList(
1650  ast, template_param_infos, template_param_decls);
1651 
1652  // LLDB needs to create those decls only to be able to display a
1653  // type that includes a template template argument. Only the name matters for
1654  // this purpose, so we use dummy values for the other characteristics of the
1655  // type.
1656  return TemplateTemplateParmDecl::Create(
1657  ast, decl_ctx, SourceLocation(),
1658  /*Depth*/ 0, /*Position*/ 0,
1659  /*IsParameterPack*/ false, &identifier_info, template_param_list);
1660 }
1661 
1662 ClassTemplateSpecializationDecl *
1664  DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1665  ClassTemplateDecl *class_template_decl, int kind,
1666  const TemplateParameterInfos &template_param_infos) {
1667  ASTContext &ast = getASTContext();
1668  llvm::SmallVector<clang::TemplateArgument, 2> args(
1669  template_param_infos.args.size() +
1670  (template_param_infos.packed_args ? 1 : 0));
1671  std::copy(template_param_infos.args.begin(), template_param_infos.args.end(),
1672  args.begin());
1673  if (template_param_infos.packed_args) {
1674  args[args.size() - 1] = TemplateArgument::CreatePackCopy(
1675  ast, template_param_infos.packed_args->args);
1676  }
1677  ClassTemplateSpecializationDecl *class_template_specialization_decl =
1678  ClassTemplateSpecializationDecl::CreateDeserialized(ast, 0);
1679  class_template_specialization_decl->setTagKind(
1680  static_cast<TagDecl::TagKind>(kind));
1681  class_template_specialization_decl->setDeclContext(decl_ctx);
1682  class_template_specialization_decl->setInstantiationOf(class_template_decl);
1683  class_template_specialization_decl->setTemplateArgs(
1684  TemplateArgumentList::CreateCopy(ast, args));
1685  ast.getTypeDeclType(class_template_specialization_decl, nullptr);
1686  class_template_specialization_decl->setDeclName(
1687  class_template_decl->getDeclName());
1688  SetOwningModule(class_template_specialization_decl, owning_module);
1689  decl_ctx->addDecl(class_template_specialization_decl);
1690 
1691  class_template_specialization_decl->setSpecializationKind(
1692  TSK_ExplicitSpecialization);
1693 
1694  return class_template_specialization_decl;
1695 }
1696 
1698  ClassTemplateSpecializationDecl *class_template_specialization_decl) {
1699  if (class_template_specialization_decl) {
1700  ASTContext &ast = getASTContext();
1701  return GetType(ast.getTagDeclType(class_template_specialization_decl));
1702  }
1703  return CompilerType();
1704 }
1705 
1706 static inline bool check_op_param(bool is_method,
1707  clang::OverloadedOperatorKind op_kind,
1708  bool unary, bool binary,
1709  uint32_t num_params) {
1710  // Special-case call since it can take any number of operands
1711  if (op_kind == OO_Call)
1712  return true;
1713 
1714  // The parameter count doesn't include "this"
1715  if (is_method)
1716  ++num_params;
1717  if (num_params == 1)
1718  return unary;
1719  if (num_params == 2)
1720  return binary;
1721  else
1722  return false;
1723 }
1724 
1726  bool is_method, clang::OverloadedOperatorKind op_kind,
1727  uint32_t num_params) {
1728  switch (op_kind) {
1729  default:
1730  break;
1731  // C++ standard allows any number of arguments to new/delete
1732  case OO_New:
1733  case OO_Array_New:
1734  case OO_Delete:
1735  case OO_Array_Delete:
1736  return true;
1737  }
1738 
1739 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
1740  case OO_##Name: \
1741  return check_op_param(is_method, op_kind, Unary, Binary, num_params);
1742  switch (op_kind) {
1743 #include "clang/Basic/OperatorKinds.def"
1744  default:
1745  break;
1746  }
1747  return false;
1748 }
1749 
1750 clang::AccessSpecifier
1751 TypeSystemClang::UnifyAccessSpecifiers(clang::AccessSpecifier lhs,
1752  clang::AccessSpecifier rhs) {
1753  // Make the access equal to the stricter of the field and the nested field's
1754  // access
1755  if (lhs == AS_none || rhs == AS_none)
1756  return AS_none;
1757  if (lhs == AS_private || rhs == AS_private)
1758  return AS_private;
1759  if (lhs == AS_protected || rhs == AS_protected)
1760  return AS_protected;
1761  return AS_public;
1762 }
1763 
1764 bool TypeSystemClang::FieldIsBitfield(FieldDecl *field,
1765  uint32_t &bitfield_bit_size) {
1766  ASTContext &ast = getASTContext();
1767  if (field == nullptr)
1768  return false;
1769 
1770  if (field->isBitField()) {
1771  Expr *bit_width_expr = field->getBitWidth();
1772  if (bit_width_expr) {
1773  if (Optional<llvm::APSInt> bit_width_apsint =
1774  bit_width_expr->getIntegerConstantExpr(ast)) {
1775  bitfield_bit_size = bit_width_apsint->getLimitedValue(UINT32_MAX);
1776  return true;
1777  }
1778  }
1779  }
1780  return false;
1781 }
1782 
1783 bool TypeSystemClang::RecordHasFields(const RecordDecl *record_decl) {
1784  if (record_decl == nullptr)
1785  return false;
1786 
1787  if (!record_decl->field_empty())
1788  return true;
1789 
1790  // No fields, lets check this is a CXX record and check the base classes
1791  const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1792  if (cxx_record_decl) {
1793  CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1794  for (base_class = cxx_record_decl->bases_begin(),
1795  base_class_end = cxx_record_decl->bases_end();
1796  base_class != base_class_end; ++base_class) {
1797  const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
1798  base_class->getType()->getAs<RecordType>()->getDecl());
1799  if (RecordHasFields(base_class_decl))
1800  return true;
1801  }
1802  }
1803  return false;
1804 }
1805 
1806 #pragma mark Objective-C Classes
1807 
1809  llvm::StringRef name, clang::DeclContext *decl_ctx,
1810  OptionalClangModuleID owning_module, bool isForwardDecl, bool isInternal,
1811  ClangASTMetadata *metadata) {
1812  ASTContext &ast = getASTContext();
1813  assert(!name.empty());
1814  if (!decl_ctx)
1815  decl_ctx = ast.getTranslationUnitDecl();
1816 
1817  ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0);
1818  decl->setDeclContext(decl_ctx);
1819  decl->setDeclName(&ast.Idents.get(name));
1820  /*isForwardDecl,*/
1821  decl->setImplicit(isInternal);
1822  SetOwningModule(decl, owning_module);
1823 
1824  if (metadata)
1825  SetMetadata(decl, *metadata);
1826 
1827  return GetType(ast.getObjCInterfaceType(decl));
1828 }
1829 
1830 static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
1831  return !TypeSystemClang::RecordHasFields(b->getType()->getAsCXXRecordDecl());
1832 }
1833 
1834 uint32_t
1835 TypeSystemClang::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
1836  bool omit_empty_base_classes) {
1837  uint32_t num_bases = 0;
1838  if (cxx_record_decl) {
1839  if (omit_empty_base_classes) {
1840  CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1841  for (base_class = cxx_record_decl->bases_begin(),
1842  base_class_end = cxx_record_decl->bases_end();
1843  base_class != base_class_end; ++base_class) {
1844  // Skip empty base classes
1845  if (BaseSpecifierIsEmpty(base_class))
1846  continue;
1847  ++num_bases;
1848  }
1849  } else
1850  num_bases = cxx_record_decl->getNumBases();
1851  }
1852  return num_bases;
1853 }
1854 
1855 #pragma mark Namespace Declarations
1856 
1858  const char *name, clang::DeclContext *decl_ctx,
1859  OptionalClangModuleID owning_module, bool is_inline) {
1860  NamespaceDecl *namespace_decl = nullptr;
1861  ASTContext &ast = getASTContext();
1862  TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl();
1863  if (!decl_ctx)
1864  decl_ctx = translation_unit_decl;
1865 
1866  if (name) {
1867  IdentifierInfo &identifier_info = ast.Idents.get(name);
1868  DeclarationName decl_name(&identifier_info);
1869  clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1870  for (NamedDecl *decl : result) {
1871  namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1872  if (namespace_decl)
1873  return namespace_decl;
1874  }
1875 
1876  namespace_decl =
1877  NamespaceDecl::Create(ast, decl_ctx, is_inline, SourceLocation(),
1878  SourceLocation(), &identifier_info, nullptr);
1879 
1880  decl_ctx->addDecl(namespace_decl);
1881  } else {
1882  if (decl_ctx == translation_unit_decl) {
1883  namespace_decl = translation_unit_decl->getAnonymousNamespace();
1884  if (namespace_decl)
1885  return namespace_decl;
1886 
1887  namespace_decl =
1888  NamespaceDecl::Create(ast, decl_ctx, false, SourceLocation(),
1889  SourceLocation(), nullptr, nullptr);
1890  translation_unit_decl->setAnonymousNamespace(namespace_decl);
1891  translation_unit_decl->addDecl(namespace_decl);
1892  assert(namespace_decl == translation_unit_decl->getAnonymousNamespace());
1893  } else {
1894  NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1895  if (parent_namespace_decl) {
1896  namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1897  if (namespace_decl)
1898  return namespace_decl;
1899  namespace_decl =
1900  NamespaceDecl::Create(ast, decl_ctx, false, SourceLocation(),
1901  SourceLocation(), nullptr, nullptr);
1902  parent_namespace_decl->setAnonymousNamespace(namespace_decl);
1903  parent_namespace_decl->addDecl(namespace_decl);
1904  assert(namespace_decl ==
1905  parent_namespace_decl->getAnonymousNamespace());
1906  } else {
1907  assert(false && "GetUniqueNamespaceDeclaration called with no name and "
1908  "no namespace as decl_ctx");
1909  }
1910  }
1911  }
1912  // Note: namespaces can span multiple modules, so perhaps this isn't a good
1913  // idea.
1914  SetOwningModule(namespace_decl, owning_module);
1915 
1916  VerifyDecl(namespace_decl);
1917  return namespace_decl;
1918 }
1919 
1920 clang::BlockDecl *
1922  OptionalClangModuleID owning_module) {
1923  if (ctx) {
1924  clang::BlockDecl *decl =
1925  clang::BlockDecl::CreateDeserialized(getASTContext(), 0);
1926  decl->setDeclContext(ctx);
1927  ctx->addDecl(decl);
1928  SetOwningModule(decl, owning_module);
1929  return decl;
1930  }
1931  return nullptr;
1932 }
1933 
1934 clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left,
1935  clang::DeclContext *right,
1936  clang::DeclContext *root) {
1937  if (root == nullptr)
1938  return nullptr;
1939 
1940  std::set<clang::DeclContext *> path_left;
1941  for (clang::DeclContext *d = left; d != nullptr; d = d->getParent())
1942  path_left.insert(d);
1943 
1944  for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
1945  if (path_left.find(d) != path_left.end())
1946  return d;
1947 
1948  return nullptr;
1949 }
1950 
1952  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1953  clang::NamespaceDecl *ns_decl) {
1954  if (decl_ctx && ns_decl) {
1955  auto *translation_unit = getASTContext().getTranslationUnitDecl();
1956  clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
1957  getASTContext(), decl_ctx, clang::SourceLocation(),
1958  clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
1959  clang::SourceLocation(), ns_decl,
1960  FindLCABetweenDecls(decl_ctx, ns_decl,
1961  translation_unit));
1962  decl_ctx->addDecl(using_decl);
1963  SetOwningModule(using_decl, owning_module);
1964  return using_decl;
1965  }
1966  return nullptr;
1967 }
1968 
1969 clang::UsingDecl *
1970 TypeSystemClang::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
1971  OptionalClangModuleID owning_module,
1972  clang::NamedDecl *target) {
1973  if (current_decl_ctx && target) {
1974  clang::UsingDecl *using_decl = clang::UsingDecl::Create(
1975  getASTContext(), current_decl_ctx, clang::SourceLocation(),
1976  clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false);
1977  SetOwningModule(using_decl, owning_module);
1978  clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
1979  getASTContext(), current_decl_ctx, clang::SourceLocation(),
1980  target->getDeclName(), using_decl, target);
1981  SetOwningModule(shadow_decl, owning_module);
1982  using_decl->addShadowDecl(shadow_decl);
1983  current_decl_ctx->addDecl(using_decl);
1984  return using_decl;
1985  }
1986  return nullptr;
1987 }
1988 
1990  clang::DeclContext *decl_context, OptionalClangModuleID owning_module,
1991  const char *name, clang::QualType type) {
1992  if (decl_context) {
1993  clang::VarDecl *var_decl =
1994  clang::VarDecl::CreateDeserialized(getASTContext(), 0);
1995  var_decl->setDeclContext(decl_context);
1996  if (name && name[0])
1997  var_decl->setDeclName(&getASTContext().Idents.getOwn(name));
1998  var_decl->setType(type);
1999  SetOwningModule(var_decl, owning_module);
2000  var_decl->setAccess(clang::AS_public);
2001  decl_context->addDecl(var_decl);
2002  return var_decl;
2003  }
2004  return nullptr;
2005 }
2006 
2009  lldb::BasicType basic_type) {
2010  switch (basic_type) {
2011  case eBasicTypeVoid:
2012  return ast->VoidTy.getAsOpaquePtr();
2013  case eBasicTypeChar:
2014  return ast->CharTy.getAsOpaquePtr();
2015  case eBasicTypeSignedChar:
2016  return ast->SignedCharTy.getAsOpaquePtr();
2018  return ast->UnsignedCharTy.getAsOpaquePtr();
2019  case eBasicTypeWChar:
2020  return ast->getWCharType().getAsOpaquePtr();
2021  case eBasicTypeSignedWChar:
2022  return ast->getSignedWCharType().getAsOpaquePtr();
2024  return ast->getUnsignedWCharType().getAsOpaquePtr();
2025  case eBasicTypeChar16:
2026  return ast->Char16Ty.getAsOpaquePtr();
2027  case eBasicTypeChar32:
2028  return ast->Char32Ty.getAsOpaquePtr();
2029  case eBasicTypeShort:
2030  return ast->ShortTy.getAsOpaquePtr();
2032  return ast->UnsignedShortTy.getAsOpaquePtr();
2033  case eBasicTypeInt:
2034  return ast->IntTy.getAsOpaquePtr();
2035  case eBasicTypeUnsignedInt:
2036  return ast->UnsignedIntTy.getAsOpaquePtr();
2037  case eBasicTypeLong:
2038  return ast->LongTy.getAsOpaquePtr();
2040  return ast->UnsignedLongTy.getAsOpaquePtr();
2041  case eBasicTypeLongLong:
2042  return ast->LongLongTy.getAsOpaquePtr();
2044  return ast->UnsignedLongLongTy.getAsOpaquePtr();
2045  case eBasicTypeInt128:
2046  return ast->Int128Ty.getAsOpaquePtr();
2048  return ast->UnsignedInt128Ty.getAsOpaquePtr();
2049  case eBasicTypeBool:
2050  return ast->BoolTy.getAsOpaquePtr();
2051  case eBasicTypeHalf:
2052  return ast->HalfTy.getAsOpaquePtr();
2053  case eBasicTypeFloat:
2054  return ast->FloatTy.getAsOpaquePtr();
2055  case eBasicTypeDouble:
2056  return ast->DoubleTy.getAsOpaquePtr();
2057  case eBasicTypeLongDouble:
2058  return ast->LongDoubleTy.getAsOpaquePtr();
2060  return ast->getComplexType(ast->FloatTy).getAsOpaquePtr();
2062  return ast->getComplexType(ast->DoubleTy).getAsOpaquePtr();
2064  return ast->getComplexType(ast->LongDoubleTy).getAsOpaquePtr();
2065  case eBasicTypeObjCID:
2066  return ast->getObjCIdType().getAsOpaquePtr();
2067  case eBasicTypeObjCClass:
2068  return ast->getObjCClassType().getAsOpaquePtr();
2069  case eBasicTypeObjCSel:
2070  return ast->getObjCSelType().getAsOpaquePtr();
2071  case eBasicTypeNullPtr:
2072  return ast->NullPtrTy.getAsOpaquePtr();
2073  default:
2074  return nullptr;
2075  }
2076 }
2077 
2078 #pragma mark Function Types
2079 
2080 clang::DeclarationName
2082  const CompilerType &function_clang_type) {
2083  clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
2084  if (!IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS)
2085  return DeclarationName(&getASTContext().Idents.get(
2086  name)); // Not operator, but a regular function.
2087 
2088  // Check the number of operator parameters. Sometimes we have seen bad DWARF
2089  // that doesn't correctly describe operators and if we try to create a method
2090  // and add it to the class, clang will assert and crash, so we need to make
2091  // sure things are acceptable.
2092  clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type));
2093  const clang::FunctionProtoType *function_type =
2094  llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
2095  if (function_type == nullptr)
2096  return clang::DeclarationName();
2097 
2098  const bool is_method = false;
2099  const unsigned int num_params = function_type->getNumParams();
2101  is_method, op_kind, num_params))
2102  return clang::DeclarationName();
2103 
2104  return getASTContext().DeclarationNames.getCXXOperatorName(op_kind);
2105 }
2106 
2108  clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
2109  printing_policy.SuppressTagKeyword = true;
2110  // Inline namespaces are important for some type formatters (e.g., libc++
2111  // and libstdc++ are differentiated by their inline namespaces).
2112  printing_policy.SuppressInlineNamespace = false;
2113  printing_policy.SuppressUnwrittenScope = false;
2114  // Default arguments are also always important for type formatters. Otherwise
2115  // we would need to always specify two type names for the setups where we do
2116  // know the default arguments and where we don't know default arguments.
2117  //
2118  // For example, without this we would need to have formatters for both:
2119  // std::basic_string<char>
2120  // and
2121  // std::basic_string<char, std::char_traits<char>, std::allocator<char> >
2122  // to support setups where LLDB was able to reconstruct default arguments
2123  // (and we then would have suppressed them from the type name) and also setups
2124  // where LLDB wasn't able to reconstruct the default arguments.
2125  printing_policy.SuppressDefaultTemplateArgs = false;
2126  return printing_policy;
2127 }
2128 
2129 std::string TypeSystemClang::GetTypeNameForDecl(const NamedDecl *named_decl) {
2130  clang::PrintingPolicy printing_policy = GetTypePrintingPolicy();
2131  std::string result;
2132  llvm::raw_string_ostream os(result);
2133  named_decl->printQualifiedName(os, printing_policy);
2134  return result;
2135 }
2136 
2138  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
2139  llvm::StringRef name, const CompilerType &function_clang_type,
2140  clang::StorageClass storage, bool is_inline) {
2141  FunctionDecl *func_decl = nullptr;
2142  ASTContext &ast = getASTContext();
2143  if (!decl_ctx)
2144  decl_ctx = ast.getTranslationUnitDecl();
2145 
2146  const bool hasWrittenPrototype = true;
2147  const bool isConstexprSpecified = false;
2148 
2149  clang::DeclarationName declarationName =
2150  GetDeclarationName(name, function_clang_type);
2151  func_decl = FunctionDecl::CreateDeserialized(ast, 0);
2152  func_decl->setDeclContext(decl_ctx);
2153  func_decl->setDeclName(declarationName);
2154  func_decl->setType(ClangUtil::GetQualType(function_clang_type));
2155  func_decl->setStorageClass(storage);
2156  func_decl->setInlineSpecified(is_inline);
2157  func_decl->setHasWrittenPrototype(hasWrittenPrototype);
2158  func_decl->setConstexprKind(isConstexprSpecified
2159  ? ConstexprSpecKind::Constexpr
2160  : ConstexprSpecKind::Unspecified);
2161  SetOwningModule(func_decl, owning_module);
2162  decl_ctx->addDecl(func_decl);
2163 
2164  VerifyDecl(func_decl);
2165 
2166  return func_decl;
2167 }
2168 
2171  const CompilerType *args, unsigned num_args,
2172  bool is_variadic, unsigned type_quals,
2173  clang::CallingConv cc) {
2174  if (!result_type || !ClangUtil::IsClangType(result_type))
2175  return CompilerType(); // invalid return type
2176 
2177  std::vector<QualType> qual_type_args;
2178  if (num_args > 0 && args == nullptr)
2179  return CompilerType(); // invalid argument array passed in
2180 
2181  // Verify that all arguments are valid and the right type
2182  for (unsigned i = 0; i < num_args; ++i) {
2183  if (args[i]) {
2184  // Make sure we have a clang type in args[i] and not a type from another
2185  // language whose name might match
2186  const bool is_clang_type = ClangUtil::IsClangType(args[i]);
2187  lldbassert(is_clang_type);
2188  if (is_clang_type)
2189  qual_type_args.push_back(ClangUtil::GetQualType(args[i]));
2190  else
2191  return CompilerType(); // invalid argument type (must be a clang type)
2192  } else
2193  return CompilerType(); // invalid argument type (empty)
2194  }
2195 
2196  // TODO: Detect calling convention in DWARF?
2197  FunctionProtoType::ExtProtoInfo proto_info;
2198  proto_info.ExtInfo = cc;
2199  proto_info.Variadic = is_variadic;
2200  proto_info.ExceptionSpec = EST_None;
2201  proto_info.TypeQuals = clang::Qualifiers::fromFastMask(type_quals);
2202  proto_info.RefQualifier = RQ_None;
2203 
2204  return GetType(getASTContext().getFunctionType(
2205  ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
2206 }
2207 
2209  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
2210  const char *name, const CompilerType &param_type, int storage,
2211  bool add_decl) {
2212  ASTContext &ast = getASTContext();
2213  auto *decl = ParmVarDecl::CreateDeserialized(ast, 0);
2214  decl->setDeclContext(decl_ctx);
2215  if (name && name[0])
2216  decl->setDeclName(&ast.Idents.get(name));
2217  decl->setType(ClangUtil::GetQualType(param_type));
2218  decl->setStorageClass(static_cast<clang::StorageClass>(storage));
2219  SetOwningModule(decl, owning_module);
2220  if (add_decl)
2221  decl_ctx->addDecl(decl);
2222 
2223  return decl;
2224 }
2225 
2227  FunctionDecl *function_decl, llvm::ArrayRef<ParmVarDecl *> params) {
2228  if (function_decl)
2229  function_decl->setParams(params);
2230 }
2231 
2234  QualType block_type = m_ast_up->getBlockPointerType(
2235  clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType()));
2236 
2237  return GetType(block_type);
2238 }
2239 
2240 #pragma mark Array Types
2241 
2243  size_t element_count,
2244  bool is_vector) {
2245  if (element_type.IsValid()) {
2246  ASTContext &ast = getASTContext();
2247 
2248  if (is_vector) {
2249  return GetType(ast.getExtVectorType(ClangUtil::GetQualType(element_type),
2250  element_count));
2251  } else {
2252 
2253  llvm::APInt ap_element_count(64, element_count);
2254  if (element_count == 0) {
2255  return GetType(ast.getIncompleteArrayType(
2256  ClangUtil::GetQualType(element_type), clang::ArrayType::Normal, 0));
2257  } else {
2258  return GetType(ast.getConstantArrayType(
2259  ClangUtil::GetQualType(element_type), ap_element_count, nullptr,
2260  clang::ArrayType::Normal, 0));
2261  }
2262  }
2263  }
2264  return CompilerType();
2265 }
2266 
2268  ConstString type_name,
2269  const std::initializer_list<std::pair<const char *, CompilerType>>
2270  &type_fields,
2271  bool packed) {
2272  CompilerType type;
2273  if (!type_name.IsEmpty() &&
2274  (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
2275  .IsValid()) {
2276  lldbassert(0 && "Trying to create a type for an existing name");
2277  return type;
2278  }
2279 
2281  type_name.GetCString(), clang::TTK_Struct,
2284  for (const auto &field : type_fields)
2285  AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic,
2286  0);
2287  if (packed)
2288  SetIsPacked(type);
2290  return type;
2291 }
2292 
2294  ConstString type_name,
2295  const std::initializer_list<std::pair<const char *, CompilerType>>
2296  &type_fields,
2297  bool packed) {
2298  CompilerType type;
2299  if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
2300  return type;
2301 
2302  return CreateStructForIdentifier(type_name, type_fields, packed);
2303 }
2304 
2305 #pragma mark Enumeration Types
2306 
2308  llvm::StringRef name, clang::DeclContext *decl_ctx,
2309  OptionalClangModuleID owning_module, const Declaration &decl,
2310  const CompilerType &integer_clang_type, bool is_scoped) {
2311  // TODO: Do something intelligent with the Declaration object passed in
2312  // like maybe filling in the SourceLocation with it...
2313  ASTContext &ast = getASTContext();
2314 
2315  // TODO: ask about these...
2316  // const bool IsFixed = false;
2317  EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0);
2318  enum_decl->setDeclContext(decl_ctx);
2319  if (!name.empty())
2320  enum_decl->setDeclName(&ast.Idents.get(name));
2321  enum_decl->setScoped(is_scoped);
2322  enum_decl->setScopedUsingClassTag(is_scoped);
2323  enum_decl->setFixed(false);
2324  SetOwningModule(enum_decl, owning_module);
2325  if (decl_ctx)
2326  decl_ctx->addDecl(enum_decl);
2327 
2328  // TODO: check if we should be setting the promotion type too?
2329  enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
2330 
2331  enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
2332 
2333  return GetType(ast.getTagDeclType(enum_decl));
2334 }
2335 
2337  bool is_signed) {
2338  clang::ASTContext &ast = getASTContext();
2339 
2340  if (is_signed) {
2341  if (bit_size == ast.getTypeSize(ast.SignedCharTy))
2342  return GetType(ast.SignedCharTy);
2343 
2344  if (bit_size == ast.getTypeSize(ast.ShortTy))
2345  return GetType(ast.ShortTy);
2346 
2347  if (bit_size == ast.getTypeSize(ast.IntTy))
2348  return GetType(ast.IntTy);
2349 
2350  if (bit_size == ast.getTypeSize(ast.LongTy))
2351  return GetType(ast.LongTy);
2352 
2353  if (bit_size == ast.getTypeSize(ast.LongLongTy))
2354  return GetType(ast.LongLongTy);
2355 
2356  if (bit_size == ast.getTypeSize(ast.Int128Ty))
2357  return GetType(ast.Int128Ty);
2358  } else {
2359  if (bit_size == ast.getTypeSize(ast.UnsignedCharTy))
2360  return GetType(ast.UnsignedCharTy);
2361 
2362  if (bit_size == ast.getTypeSize(ast.UnsignedShortTy))
2363  return GetType(ast.UnsignedShortTy);
2364 
2365  if (bit_size == ast.getTypeSize(ast.UnsignedIntTy))
2366  return GetType(ast.UnsignedIntTy);
2367 
2368  if (bit_size == ast.getTypeSize(ast.UnsignedLongTy))
2369  return GetType(ast.UnsignedLongTy);
2370 
2371  if (bit_size == ast.getTypeSize(ast.UnsignedLongLongTy))
2372  return GetType(ast.UnsignedLongLongTy);
2373 
2374  if (bit_size == ast.getTypeSize(ast.UnsignedInt128Ty))
2375  return GetType(ast.UnsignedInt128Ty);
2376  }
2377  return CompilerType();
2378 }
2379 
2381  return GetIntTypeFromBitSize(
2382  getASTContext().getTypeSize(getASTContext().VoidPtrTy), is_signed);
2383 }
2384 
2385 void TypeSystemClang::DumpDeclContextHiearchy(clang::DeclContext *decl_ctx) {
2386  if (decl_ctx) {
2387  DumpDeclContextHiearchy(decl_ctx->getParent());
2388 
2389  clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
2390  if (named_decl) {
2391  printf("%20s: %s\n", decl_ctx->getDeclKindName(),
2392  named_decl->getDeclName().getAsString().c_str());
2393  } else {
2394  printf("%20s\n", decl_ctx->getDeclKindName());
2395  }
2396  }
2397 }
2398 
2399 void TypeSystemClang::DumpDeclHiearchy(clang::Decl *decl) {
2400  if (decl == nullptr)
2401  return;
2402  DumpDeclContextHiearchy(decl->getDeclContext());
2403 
2404  clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
2405  if (record_decl) {
2406  printf("%20s: %s%s\n", decl->getDeclKindName(),
2407  record_decl->getDeclName().getAsString().c_str(),
2408  record_decl->isInjectedClassName() ? " (injected class name)" : "");
2409 
2410  } else {
2411  clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
2412  if (named_decl) {
2413  printf("%20s: %s\n", decl->getDeclKindName(),
2414  named_decl->getDeclName().getAsString().c_str());
2415  } else {
2416  printf("%20s\n", decl->getDeclKindName());
2417  }
2418  }
2419 }
2420 
2421 bool TypeSystemClang::DeclsAreEquivalent(clang::Decl *lhs_decl,
2422  clang::Decl *rhs_decl) {
2423  if (lhs_decl && rhs_decl) {
2424  // Make sure the decl kinds match first
2425  const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
2426  const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
2427 
2428  if (lhs_decl_kind == rhs_decl_kind) {
2429  // Now check that the decl contexts kinds are all equivalent before we
2430  // have to check any names of the decl contexts...
2431  clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
2432  clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
2433  if (lhs_decl_ctx && rhs_decl_ctx) {
2434  while (true) {
2435  if (lhs_decl_ctx && rhs_decl_ctx) {
2436  const clang::Decl::Kind lhs_decl_ctx_kind =
2437  lhs_decl_ctx->getDeclKind();
2438  const clang::Decl::Kind rhs_decl_ctx_kind =
2439  rhs_decl_ctx->getDeclKind();
2440  if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) {
2441  lhs_decl_ctx = lhs_decl_ctx->getParent();
2442  rhs_decl_ctx = rhs_decl_ctx->getParent();
2443 
2444  if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr)
2445  break;
2446  } else
2447  return false;
2448  } else
2449  return false;
2450  }
2451 
2452  // Now make sure the name of the decls match
2453  clang::NamedDecl *lhs_named_decl =
2454  llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
2455  clang::NamedDecl *rhs_named_decl =
2456  llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
2457  if (lhs_named_decl && rhs_named_decl) {
2458  clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2459  clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2460  if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2461  if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2462  return false;
2463  } else
2464  return false;
2465  } else
2466  return false;
2467 
2468  // We know that the decl context kinds all match, so now we need to
2469  // make sure the names match as well
2470  lhs_decl_ctx = lhs_decl->getDeclContext();
2471  rhs_decl_ctx = rhs_decl->getDeclContext();
2472  while (true) {
2473  switch (lhs_decl_ctx->getDeclKind()) {
2474  case clang::Decl::TranslationUnit:
2475  // We don't care about the translation unit names
2476  return true;
2477  default: {
2478  clang::NamedDecl *lhs_named_decl =
2479  llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
2480  clang::NamedDecl *rhs_named_decl =
2481  llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
2482  if (lhs_named_decl && rhs_named_decl) {
2483  clang::DeclarationName lhs_decl_name =
2484  lhs_named_decl->getDeclName();
2485  clang::DeclarationName rhs_decl_name =
2486  rhs_named_decl->getDeclName();
2487  if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2488  if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2489  return false;
2490  } else
2491  return false;
2492  } else
2493  return false;
2494  } break;
2495  }
2496  lhs_decl_ctx = lhs_decl_ctx->getParent();
2497  rhs_decl_ctx = rhs_decl_ctx->getParent();
2498  }
2499  }
2500  }
2501  }
2502  return false;
2503 }
2504 bool TypeSystemClang::GetCompleteDecl(clang::ASTContext *ast,
2505  clang::Decl *decl) {
2506  if (!decl)
2507  return false;
2508 
2509  ExternalASTSource *ast_source = ast->getExternalSource();
2510 
2511  if (!ast_source)
2512  return false;
2513 
2514  if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
2515  if (tag_decl->isCompleteDefinition())
2516  return true;
2517 
2518  if (!tag_decl->hasExternalLexicalStorage())
2519  return false;
2520 
2521  ast_source->CompleteType(tag_decl);
2522 
2523  return !tag_decl->getTypeForDecl()->isIncompleteType();
2524  } else if (clang::ObjCInterfaceDecl *objc_interface_decl =
2525  llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) {
2526  if (objc_interface_decl->getDefinition())
2527  return true;
2528 
2529  if (!objc_interface_decl->hasExternalLexicalStorage())
2530  return false;
2531 
2532  ast_source->CompleteType(objc_interface_decl);
2533 
2534  return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2535  } else {
2536  return false;
2537  }
2538 }
2539 
2540 void TypeSystemClang::SetMetadataAsUserID(const clang::Decl *decl,
2541  user_id_t user_id) {
2542  ClangASTMetadata meta_data;
2543  meta_data.SetUserID(user_id);
2544  SetMetadata(decl, meta_data);
2545 }
2546 
2547 void TypeSystemClang::SetMetadataAsUserID(const clang::Type *type,
2548  user_id_t user_id) {
2549  ClangASTMetadata meta_data;
2550  meta_data.SetUserID(user_id);
2551  SetMetadata(type, meta_data);
2552 }
2553 
2554 void TypeSystemClang::SetMetadata(const clang::Decl *object,
2555  ClangASTMetadata &metadata) {
2556  m_decl_metadata[object] = metadata;
2557 }
2558 
2559 void TypeSystemClang::SetMetadata(const clang::Type *object,
2560  ClangASTMetadata &metadata) {
2561  m_type_metadata[object] = metadata;
2562 }
2563 
2564 ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Decl *object) {
2565  auto It = m_decl_metadata.find(object);
2566  if (It != m_decl_metadata.end())
2567  return &It->second;
2568  return nullptr;
2569 }
2570 
2571 ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Type *object) {
2572  auto It = m_type_metadata.find(object);
2573  if (It != m_type_metadata.end())
2574  return &It->second;
2575  return nullptr;
2576 }
2577 
2578 void TypeSystemClang::SetCXXRecordDeclAccess(const clang::CXXRecordDecl *object,
2579  clang::AccessSpecifier access) {
2580  if (access == clang::AccessSpecifier::AS_none)
2581  m_cxx_record_decl_access.erase(object);
2582  else
2583  m_cxx_record_decl_access[object] = access;
2584 }
2585 
2586 clang::AccessSpecifier
2587 TypeSystemClang::GetCXXRecordDeclAccess(const clang::CXXRecordDecl *object) {
2588  auto It = m_cxx_record_decl_access.find(object);
2589  if (It != m_cxx_record_decl_access.end())
2590  return It->second;
2591  return clang::AccessSpecifier::AS_none;
2592 }
2593 
2594 clang::DeclContext *
2597 }
2598 
2599 /// Aggressively desugar the provided type, skipping past various kinds of
2600 /// syntactic sugar and other constructs one typically wants to ignore.
2601 /// The \p mask argument allows one to skip certain kinds of simplifications,
2602 /// when one wishes to handle a certain kind of type directly.
2603 static QualType
2604 RemoveWrappingTypes(QualType type, ArrayRef<clang::Type::TypeClass> mask = {}) {
2605  while (true) {
2606  if (find(mask, type->getTypeClass()) != mask.end())
2607  return type;
2608  switch (type->getTypeClass()) {
2609  // This is not fully correct as _Atomic is more than sugar, but it is
2610  // sufficient for the purposes we care about.
2611  case clang::Type::Atomic:
2612  type = cast<clang::AtomicType>(type)->getValueType();
2613  break;
2614  case clang::Type::Auto:
2615  case clang::Type::Decltype:
2616  case clang::Type::Elaborated:
2617  case clang::Type::Paren:
2618  case clang::Type::SubstTemplateTypeParm:
2619  case clang::Type::TemplateSpecialization:
2620  case clang::Type::Typedef:
2621  case clang::Type::TypeOf:
2622  case clang::Type::TypeOfExpr:
2623  case clang::Type::Using:
2624  type = type->getLocallyUnqualifiedSingleStepDesugaredType();
2625  break;
2626  default:
2627  return type;
2628  }
2629  }
2630 }
2631 
2632 clang::DeclContext *
2634  if (type.isNull())
2635  return nullptr;
2636 
2637  clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
2638  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2639  switch (type_class) {
2640  case clang::Type::ObjCInterface:
2641  return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
2642  ->getInterface();
2643  case clang::Type::ObjCObjectPointer:
2644  return GetDeclContextForType(
2645  llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
2646  ->getPointeeType());
2647  case clang::Type::Record:
2648  return llvm::cast<clang::RecordType>(qual_type)->getDecl();
2649  case clang::Type::Enum:
2650  return llvm::cast<clang::EnumType>(qual_type)->getDecl();
2651  default:
2652  break;
2653  }
2654  // No DeclContext in this type...
2655  return nullptr;
2656 }
2657 
2658 static bool GetCompleteQualType(clang::ASTContext *ast,
2659  clang::QualType qual_type,
2660  bool allow_completion = true) {
2661  qual_type = RemoveWrappingTypes(qual_type);
2662  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2663  switch (type_class) {
2664  case clang::Type::ConstantArray:
2665  case clang::Type::IncompleteArray:
2666  case clang::Type::VariableArray: {
2667  const clang::ArrayType *array_type =
2668  llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
2669 
2670  if (array_type)
2671  return GetCompleteQualType(ast, array_type->getElementType(),
2672  allow_completion);
2673  } break;
2674  case clang::Type::Record: {
2675  clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2676  if (cxx_record_decl) {
2677  if (cxx_record_decl->hasExternalLexicalStorage()) {
2678  const bool is_complete = cxx_record_decl->isCompleteDefinition();
2679  const bool fields_loaded =
2680  cxx_record_decl->hasLoadedFieldsFromExternalStorage();
2681  if (is_complete && fields_loaded)
2682  return true;
2683 
2684  if (!allow_completion)
2685  return false;
2686 
2687  // Call the field_begin() accessor to for it to use the external source
2688  // to load the fields...
2689  clang::ExternalASTSource *external_ast_source =
2690  ast->getExternalSource();
2691  if (external_ast_source) {
2692  external_ast_source->CompleteType(cxx_record_decl);
2693  if (cxx_record_decl->isCompleteDefinition()) {
2694  cxx_record_decl->field_begin();
2695  cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
2696  }
2697  }
2698  }
2699  }
2700  const clang::TagType *tag_type =
2701  llvm::cast<clang::TagType>(qual_type.getTypePtr());
2702  return !tag_type->isIncompleteType();
2703  } break;
2704 
2705  case clang::Type::Enum: {
2706  const clang::TagType *tag_type =
2707  llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
2708  if (tag_type) {
2709  clang::TagDecl *tag_decl = tag_type->getDecl();
2710  if (tag_decl) {
2711  if (tag_decl->getDefinition())
2712  return true;
2713 
2714  if (!allow_completion)
2715  return false;
2716 
2717  if (tag_decl->hasExternalLexicalStorage()) {
2718  if (ast) {
2719  clang::ExternalASTSource *external_ast_source =
2720  ast->getExternalSource();
2721  if (external_ast_source) {
2722  external_ast_source->CompleteType(tag_decl);
2723  return !tag_type->isIncompleteType();
2724  }
2725  }
2726  }
2727  return false;
2728  }
2729  }
2730 
2731  } break;
2732  case clang::Type::ObjCObject:
2733  case clang::Type::ObjCInterface: {
2734  const clang::ObjCObjectType *objc_class_type =
2735  llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
2736  if (objc_class_type) {
2737  clang::ObjCInterfaceDecl *class_interface_decl =
2738  objc_class_type->getInterface();
2739  // We currently can't complete objective C types through the newly added
2740  // ASTContext because it only supports TagDecl objects right now...
2741  if (class_interface_decl) {
2742  if (class_interface_decl->getDefinition())
2743  return true;
2744 
2745  if (!allow_completion)
2746  return false;
2747 
2748  if (class_interface_decl->hasExternalLexicalStorage()) {
2749  if (ast) {
2750  clang::ExternalASTSource *external_ast_source =
2751  ast->getExternalSource();
2752  if (external_ast_source) {
2753  external_ast_source->CompleteType(class_interface_decl);
2754  return !objc_class_type->isIncompleteType();
2755  }
2756  }
2757  }
2758  return false;
2759  }
2760  }
2761  } break;
2762 
2763  case clang::Type::Attributed:
2764  return GetCompleteQualType(
2765  ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(),
2766  allow_completion);
2767 
2768  default:
2769  break;
2770  }
2771 
2772  return true;
2773 }
2774 
2775 static clang::ObjCIvarDecl::AccessControl
2777  switch (access) {
2778  case eAccessNone:
2779  return clang::ObjCIvarDecl::None;
2780  case eAccessPublic:
2781  return clang::ObjCIvarDecl::Public;
2782  case eAccessPrivate:
2783  return clang::ObjCIvarDecl::Private;
2784  case eAccessProtected:
2785  return clang::ObjCIvarDecl::Protected;
2786  case eAccessPackage:
2787  return clang::ObjCIvarDecl::Package;
2788  }
2789  return clang::ObjCIvarDecl::None;
2790 }
2791 
2792 // Tests
2793 
2794 #ifndef NDEBUG
2796  return !type || llvm::isa<clang::Type>(GetQualType(type).getTypePtr());
2797 }
2798 #endif
2799 
2801  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
2802 
2803  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2804  switch (type_class) {
2805  case clang::Type::IncompleteArray:
2806  case clang::Type::VariableArray:
2807  case clang::Type::ConstantArray:
2808  case clang::Type::ExtVector:
2809  case clang::Type::Vector:
2810  case clang::Type::Record:
2811  case clang::Type::ObjCObject:
2812  case clang::Type::ObjCInterface:
2813  return true;
2814  default:
2815  break;
2816  }
2817  // The clang type does have a value
2818  return false;
2819 }
2820 
2822  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
2823 
2824  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2825  switch (type_class) {
2826  case clang::Type::Record: {
2827  if (const clang::RecordType *record_type =
2828  llvm::dyn_cast_or_null<clang::RecordType>(
2829  qual_type.getTypePtrOrNull())) {
2830  if (const clang::RecordDecl *record_decl = record_type->getDecl()) {
2831  return record_decl->isAnonymousStructOrUnion();
2832  }
2833  }
2834  break;
2835  }
2836  default:
2837  break;
2838  }
2839  // The clang type does have a value
2840  return false;
2841 }
2842 
2844  CompilerType *element_type_ptr,
2845  uint64_t *size, bool *is_incomplete) {
2846  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
2847 
2848  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2849  switch (type_class) {
2850  default:
2851  break;
2852 
2853  case clang::Type::ConstantArray:
2854  if (element_type_ptr)
2855  element_type_ptr->SetCompilerType(
2856  this, llvm::cast<clang::ConstantArrayType>(qual_type)
2857  ->getElementType()
2858  .getAsOpaquePtr());
2859  if (size)
2860  *size = llvm::cast<clang::ConstantArrayType>(qual_type)
2861  ->getSize()
2862  .getLimitedValue(ULLONG_MAX);
2863  if (is_incomplete)
2864  *is_incomplete = false;
2865  return true;
2866 
2867  case clang::Type::IncompleteArray:
2868  if (element_type_ptr)
2869  element_type_ptr->SetCompilerType(
2870  this, llvm::cast<clang::IncompleteArrayType>(qual_type)
2871  ->getElementType()
2872  .getAsOpaquePtr());
2873  if (size)
2874  *size = 0;
2875  if (is_incomplete)
2876  *is_incomplete = true;
2877  return true;
2878 
2879  case clang::Type::VariableArray:
2880  if (element_type_ptr)
2881  element_type_ptr->SetCompilerType(
2882  this, llvm::cast<clang::VariableArrayType>(qual_type)
2883  ->getElementType()
2884  .getAsOpaquePtr());
2885  if (size)
2886  *size = 0;
2887  if (is_incomplete)
2888  *is_incomplete = false;
2889  return true;
2890 
2891  case clang::Type::DependentSizedArray:
2892  if (element_type_ptr)
2893  element_type_ptr->SetCompilerType(
2894  this, llvm::cast<clang::DependentSizedArrayType>(qual_type)
2895  ->getElementType()
2896  .getAsOpaquePtr());
2897  if (size)
2898  *size = 0;
2899  if (is_incomplete)
2900  *is_incomplete = false;
2901  return true;
2902  }
2903  if (element_type_ptr)
2904  element_type_ptr->Clear();
2905  if (size)
2906  *size = 0;
2907  if (is_incomplete)
2908  *is_incomplete = false;
2909  return false;
2910 }
2911 
2913  CompilerType *element_type, uint64_t *size) {
2914  clang::QualType qual_type(GetCanonicalQualType(type));
2915 
2916  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2917  switch (type_class) {
2918  case clang::Type::Vector: {
2919  const clang::VectorType *vector_type =
2920  qual_type->getAs<clang::VectorType>();
2921  if (vector_type) {
2922  if (size)
2923  *size = vector_type->getNumElements();
2924  if (element_type)
2925  *element_type = GetType(vector_type->getElementType());
2926  }
2927  return true;
2928  } break;
2929  case clang::Type::ExtVector: {
2930  const clang::ExtVectorType *ext_vector_type =
2931  qual_type->getAs<clang::ExtVectorType>();
2932  if (ext_vector_type) {
2933  if (size)
2934  *size = ext_vector_type->getNumElements();
2935  if (element_type)
2936  *element_type =
2937  CompilerType(this, ext_vector_type->getElementType().getAsOpaquePtr());
2938  }
2939  return true;
2940  }
2941  default:
2942  break;
2943  }
2944  return false;
2945 }
2946 
2949  clang::DeclContext *decl_ctx = GetDeclContextForType(GetQualType(type));
2950  if (!decl_ctx)
2951  return false;
2952 
2953  if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
2954  return false;
2955 
2956  clang::ObjCInterfaceDecl *result_iface_decl =
2957  llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
2958 
2959  ClangASTMetadata *ast_metadata = GetMetadata(result_iface_decl);
2960  if (!ast_metadata)
2961  return false;
2962  return (ast_metadata->GetISAPtr() != 0);
2963 }
2964 
2966  return GetQualType(type).getUnqualifiedType()->isCharType();
2967 }
2968 
2970  // If the type hasn't been lazily completed yet, complete it now so that we
2971  // can give the caller an accurate answer whether the type actually has a
2972  // definition. Without completing the type now we would just tell the user
2973  // the current (internal) completeness state of the type and most users don't
2974  // care (or even know) about this behavior.
2975  const bool allow_completion = true;
2977  allow_completion);
2978 }
2979 
2981  return GetQualType(type).isConstQualified();
2982 }
2983 
2985  uint32_t &length) {
2986  CompilerType pointee_or_element_clang_type;
2987  length = 0;
2988  Flags type_flags(GetTypeInfo(type, &pointee_or_element_clang_type));
2989 
2990  if (!pointee_or_element_clang_type.IsValid())
2991  return false;
2992 
2993  if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) {
2994  if (pointee_or_element_clang_type.IsCharType()) {
2995  if (type_flags.Test(eTypeIsArray)) {
2996  // We know the size of the array and it could be a C string since it is
2997  // an array of characters
2998  length = llvm::cast<clang::ConstantArrayType>(
2999  GetCanonicalQualType(type).getTypePtr())
3000  ->getSize()
3001  .getLimitedValue();
3002  }
3003  return true;
3004  }
3005  }
3006  return false;
3007 }
3008 
3010  if (type) {
3011  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3012 
3013  if (qual_type->isFunctionType()) {
3014  return true;
3015  }
3016 
3017  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3018  switch (type_class) {
3019  default:
3020  break;
3021  case clang::Type::LValueReference:
3022  case clang::Type::RValueReference: {
3023  const clang::ReferenceType *reference_type =
3024  llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3025  if (reference_type)
3026  return IsFunctionType(
3027  reference_type->getPointeeType().getAsOpaquePtr());
3028  } break;
3029  }
3030  }
3031  return false;
3032 }
3033 
3034 // Used to detect "Homogeneous Floating-point Aggregates"
3035 uint32_t
3037  CompilerType *base_type_ptr) {
3038  if (!type)
3039  return 0;
3040 
3041  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
3042  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3043  switch (type_class) {
3044  case clang::Type::Record:
3045  if (GetCompleteType(type)) {
3046  const clang::CXXRecordDecl *cxx_record_decl =
3047  qual_type->getAsCXXRecordDecl();
3048  if (cxx_record_decl) {
3049  if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass())
3050  return 0;
3051  }
3052  const clang::RecordType *record_type =
3053  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3054  if (record_type) {
3055  const clang::RecordDecl *record_decl = record_type->getDecl();
3056  if (record_decl) {
3057  // We are looking for a structure that contains only floating point
3058  // types
3059  clang::RecordDecl::field_iterator field_pos,
3060  field_end = record_decl->field_end();
3061  uint32_t num_fields = 0;
3062  bool is_hva = false;
3063  bool is_hfa = false;
3064  clang::QualType base_qual_type;
3065  uint64_t base_bitwidth = 0;
3066  for (field_pos = record_decl->field_begin(); field_pos != field_end;
3067  ++field_pos) {
3068  clang::QualType field_qual_type = field_pos->getType();
3069  uint64_t field_bitwidth = getASTContext().getTypeSize(qual_type);
3070  if (field_qual_type->isFloatingType()) {
3071  if (field_qual_type->isComplexType())
3072  return 0;
3073  else {
3074  if (num_fields == 0)
3075  base_qual_type = field_qual_type;
3076  else {
3077  if (is_hva)
3078  return 0;
3079  is_hfa = true;
3080  if (field_qual_type.getTypePtr() !=
3081  base_qual_type.getTypePtr())
3082  return 0;
3083  }
3084  }
3085  } else if (field_qual_type->isVectorType() ||
3086  field_qual_type->isExtVectorType()) {
3087  if (num_fields == 0) {
3088  base_qual_type = field_qual_type;
3089  base_bitwidth = field_bitwidth;
3090  } else {
3091  if (is_hfa)
3092  return 0;
3093  is_hva = true;
3094  if (base_bitwidth != field_bitwidth)
3095  return 0;
3096  if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3097  return 0;
3098  }
3099  } else
3100  return 0;
3101  ++num_fields;
3102  }
3103  if (base_type_ptr)
3104  *base_type_ptr = CompilerType(this, base_qual_type.getAsOpaquePtr());
3105  return num_fields;
3106  }
3107  }
3108  }
3109  break;
3110 
3111  default:
3112  break;
3113  }
3114  return 0;
3115 }
3116 
3119  if (type) {
3120  clang::QualType qual_type(GetCanonicalQualType(type));
3121  const clang::FunctionProtoType *func =
3122  llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3123  if (func)
3124  return func->getNumParams();
3125  }
3126  return 0;
3127 }
3128 
3131  const size_t index) {
3132  if (type) {
3133  clang::QualType qual_type(GetQualType(type));
3134  const clang::FunctionProtoType *func =
3135  llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3136  if (func) {
3137  if (index < func->getNumParams())
3138  return CompilerType(this, func->getParamType(index).getAsOpaquePtr());
3139  }
3140  }
3141  return CompilerType();
3142 }
3143 
3145  if (type) {
3146  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3147 
3148  if (qual_type->isFunctionPointerType())
3149  return true;
3150 
3151  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3152  switch (type_class) {
3153  default:
3154  break;
3155 
3156  case clang::Type::LValueReference:
3157  case clang::Type::RValueReference: {
3158  const clang::ReferenceType *reference_type =
3159  llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3160  if (reference_type)
3161  return IsFunctionPointerType(
3162  reference_type->getPointeeType().getAsOpaquePtr());
3163  } break;
3164  }
3165  }
3166  return false;
3167 }
3168 
3171  CompilerType *function_pointer_type_ptr) {
3172  if (type) {
3173  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3174 
3175  if (qual_type->isBlockPointerType()) {
3176  if (function_pointer_type_ptr) {
3177  const clang::BlockPointerType *block_pointer_type =
3178  qual_type->getAs<clang::BlockPointerType>();
3179  QualType pointee_type = block_pointer_type->getPointeeType();
3180  QualType function_pointer_type = m_ast_up->getPointerType(pointee_type);
3181  *function_pointer_type_ptr =
3182  CompilerType(this, function_pointer_type.getAsOpaquePtr());
3183  }
3184  return true;
3185  }
3186 
3187  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3188  switch (type_class) {
3189  default:
3190  break;
3191 
3192  case clang::Type::LValueReference:
3193  case clang::Type::RValueReference: {
3194  const clang::ReferenceType *reference_type =
3195  llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3196  if (reference_type)
3197  return IsBlockPointerType(
3198  reference_type->getPointeeType().getAsOpaquePtr(),
3199  function_pointer_type_ptr);
3200  } break;
3201  }
3202  }
3203  return false;
3204 }
3205 
3207  bool &is_signed) {
3208  if (!type)
3209  return false;
3210 
3211  clang::QualType qual_type(GetCanonicalQualType(type));
3212  const clang::BuiltinType *builtin_type =
3213  llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3214 
3215  if (builtin_type) {
3216  if (builtin_type->isInteger()) {
3217  is_signed = builtin_type->isSignedInteger();
3218  return true;
3219  }
3220  }
3221 
3222  return false;
3223 }
3224 
3226  bool &is_signed) {
3227  if (type) {
3228  const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3229  GetCanonicalQualType(type)->getCanonicalTypeInternal());
3230 
3231  if (enum_type) {
3232  IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
3233  is_signed);
3234  return true;
3235  }
3236  }
3237 
3238  return false;
3239 }
3240 
3243  if (type) {
3244  const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3245  GetCanonicalQualType(type)->getCanonicalTypeInternal());
3246 
3247  if (enum_type) {
3248  return enum_type->isScopedEnumeralType();
3249  }
3250  }
3251 
3252  return false;
3253 }
3254 
3256  CompilerType *pointee_type) {
3257  if (type) {
3258  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3259  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3260  switch (type_class) {
3261  case clang::Type::Builtin:
3262  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3263  default:
3264  break;
3265  case clang::BuiltinType::ObjCId:
3266  case clang::BuiltinType::ObjCClass:
3267  return true;
3268  }
3269  return false;
3270  case clang::Type::ObjCObjectPointer:
3271  if (pointee_type)
3272  pointee_type->SetCompilerType(
3273  this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3274  ->getPointeeType()
3275  .getAsOpaquePtr());
3276  return true;
3277  case clang::Type::BlockPointer:
3278  if (pointee_type)
3279  pointee_type->SetCompilerType(
3280  this, llvm::cast<clang::BlockPointerType>(qual_type)
3281  ->getPointeeType()
3282  .getAsOpaquePtr());
3283  return true;
3284  case clang::Type::Pointer:
3285  if (pointee_type)
3286  pointee_type->SetCompilerType(this,
3287  llvm::cast<clang::PointerType>(qual_type)
3288  ->getPointeeType()
3289  .getAsOpaquePtr());
3290  return true;
3291  case clang::Type::MemberPointer:
3292  if (pointee_type)
3293  pointee_type->SetCompilerType(
3294  this, llvm::cast<clang::MemberPointerType>(qual_type)
3295  ->getPointeeType()
3296  .getAsOpaquePtr());
3297  return true;
3298  default:
3299  break;
3300  }
3301  }
3302  if (pointee_type)
3303  pointee_type->Clear();
3304  return false;
3305 }
3306 
3308  lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
3309  if (type) {
3310  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3311  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3312  switch (type_class) {
3313  case clang::Type::Builtin:
3314  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3315  default:
3316  break;
3317  case clang::BuiltinType::ObjCId:
3318  case clang::BuiltinType::ObjCClass:
3319  return true;
3320  }
3321  return false;
3322  case clang::Type::ObjCObjectPointer:
3323  if (pointee_type)
3324  pointee_type->SetCompilerType(
3325  this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3326  ->getPointeeType().getAsOpaquePtr());
3327  return true;
3328  case clang::Type::BlockPointer:
3329  if (pointee_type)
3330  pointee_type->SetCompilerType(
3331  this, llvm::cast<clang::BlockPointerType>(qual_type)
3332  ->getPointeeType()
3333  .getAsOpaquePtr());
3334  return true;
3335  case clang::Type::Pointer:
3336  if (pointee_type)
3337  pointee_type->SetCompilerType(this,
3338  llvm::cast<clang::PointerType>(qual_type)
3339  ->getPointeeType()
3340  .getAsOpaquePtr());
3341  return true;
3342  case clang::Type::MemberPointer:
3343  if (pointee_type)
3344  pointee_type->SetCompilerType(
3345  this, llvm::cast<clang::MemberPointerType>(qual_type)
3346  ->getPointeeType()
3347  .getAsOpaquePtr());
3348  return true;
3349  case clang::Type::LValueReference:
3350  if (pointee_type)
3351  pointee_type->SetCompilerType(
3352  this, llvm::cast<clang::LValueReferenceType>(qual_type)
3353  ->desugar()
3354  .getAsOpaquePtr());
3355  return true;
3356  case clang::Type::RValueReference:
3357  if (pointee_type)
3358  pointee_type->SetCompilerType(
3359  this, llvm::cast<clang::RValueReferenceType>(qual_type)
3360  ->desugar()
3361  .getAsOpaquePtr());
3362  return true;
3363  default:
3364  break;
3365  }
3366  }
3367  if (pointee_type)
3368  pointee_type->Clear();
3369  return false;
3370 }
3371 
3373  CompilerType *pointee_type,
3374  bool *is_rvalue) {
3375  if (type) {
3376  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3377  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3378 
3379  switch (type_class) {
3380  case clang::Type::LValueReference:
3381  if (pointee_type)
3382  pointee_type->SetCompilerType(
3383  this, llvm::cast<clang::LValueReferenceType>(qual_type)
3384  ->desugar()
3385  .getAsOpaquePtr());
3386  if (is_rvalue)
3387  *is_rvalue = false;
3388  return true;
3389  case clang::Type::RValueReference:
3390  if (pointee_type)
3391  pointee_type->SetCompilerType(
3392  this, llvm::cast<clang::RValueReferenceType>(qual_type)
3393  ->desugar()
3394  .getAsOpaquePtr());
3395  if (is_rvalue)
3396  *is_rvalue = true;
3397  return true;
3398 
3399  default:
3400  break;
3401  }
3402  }
3403  if (pointee_type)
3404  pointee_type->Clear();
3405  return false;
3406 }
3407 
3409  uint32_t &count, bool &is_complex) {
3410  if (type) {
3411  clang::QualType qual_type(GetCanonicalQualType(type));
3412 
3413  if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
3414  qual_type->getCanonicalTypeInternal())) {
3415  clang::BuiltinType::Kind kind = BT->getKind();
3416  if (kind >= clang::BuiltinType::Float &&
3417  kind <= clang::BuiltinType::LongDouble) {
3418  count = 1;
3419  is_complex = false;
3420  return true;
3421  }
3422  } else if (const clang::ComplexType *CT =
3423  llvm::dyn_cast<clang::ComplexType>(
3424  qual_type->getCanonicalTypeInternal())) {
3425  if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count,
3426  is_complex)) {
3427  count = 2;
3428  is_complex = true;
3429  return true;
3430  }
3431  } else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(
3432  qual_type->getCanonicalTypeInternal())) {
3433  if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count,
3434  is_complex)) {
3435  count = VT->getNumElements();
3436  is_complex = false;
3437  return true;
3438  }
3439  }
3440  }
3441  count = 0;
3442  is_complex = false;
3443  return false;
3444 }
3445 
3447  if (!type)
3448  return false;
3449 
3450  clang::QualType qual_type(GetQualType(type));
3451  const clang::TagType *tag_type =
3452  llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
3453  if (tag_type) {
3454  clang::TagDecl *tag_decl = tag_type->getDecl();
3455  if (tag_decl)
3456  return tag_decl->isCompleteDefinition();
3457  return false;
3458  } else {
3459  const clang::ObjCObjectType *objc_class_type =
3460  llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3461  if (objc_class_type) {
3462  clang::ObjCInterfaceDecl *class_interface_decl =
3463  objc_class_type->getInterface();
3464  if (class_interface_decl)
3465  return class_interface_decl->getDefinition() != nullptr;
3466  return false;
3467  }
3468  }
3469  return true;
3470 }
3471 
3473  if (ClangUtil::IsClangType(type)) {
3474  clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3475 
3476  const clang::ObjCObjectPointerType *obj_pointer_type =
3477  llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3478 
3479  if (obj_pointer_type)
3480  return obj_pointer_type->isObjCClassType();
3481  }
3482  return false;
3483 }
3484 
3486  if (ClangUtil::IsClangType(type))
3487  return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
3488  return false;
3489 }
3490 
3492  if (!type)
3493  return false;
3494  clang::QualType qual_type(GetCanonicalQualType(type));
3495  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3496  return (type_class == clang::Type::Record);
3497 }
3498 
3500  if (!type)
3501  return false;
3502  clang::QualType qual_type(GetCanonicalQualType(type));
3503  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3504  return (type_class == clang::Type::Enum);
3505 }
3506 
3508  if (type) {
3509  clang::QualType qual_type(GetCanonicalQualType(type));
3510  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3511  switch (type_class) {
3512  case clang::Type::Record:
3513  if (GetCompleteType(type)) {
3514  const clang::RecordType *record_type =
3515  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3516  const clang::RecordDecl *record_decl = record_type->getDecl();
3517  if (record_decl) {
3518  const clang::CXXRecordDecl *cxx_record_decl =
3519  llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3520  if (cxx_record_decl)
3521  return cxx_record_decl->isPolymorphic();
3522  }
3523  }
3524  break;
3525 
3526  default:
3527  break;
3528  }
3529  }
3530  return false;
3531 }
3532 
3534  CompilerType *dynamic_pointee_type,
3535  bool check_cplusplus,
3536  bool check_objc) {
3537  clang::QualType pointee_qual_type;
3538  if (type) {
3539  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
3540  bool success = false;
3541  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3542  switch (type_class) {
3543  case clang::Type::Builtin:
3544  if (check_objc &&
3545  llvm::cast<clang::BuiltinType>(qual_type)->getKind() ==
3546  clang::BuiltinType::ObjCId) {
3547  if (dynamic_pointee_type)
3548  dynamic_pointee_type->SetCompilerType(this, type);
3549  return true;
3550  }
3551  break;
3552 
3553  case clang::Type::ObjCObjectPointer:
3554  if (check_objc) {
3555  if (const auto *objc_pointee_type =
3556  qual_type->getPointeeType().getTypePtrOrNull()) {
3557  if (const auto *objc_object_type =
3558  llvm::dyn_cast_or_null<clang::ObjCObjectType>(
3559  objc_pointee_type)) {
3560  if (objc_object_type->isObjCClass())
3561  return false;
3562  }
3563  }
3564  if (dynamic_pointee_type)
3565  dynamic_pointee_type->SetCompilerType(
3566  this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3567  ->getPointeeType()
3568  .getAsOpaquePtr());
3569  return true;
3570  }
3571  break;
3572 
3573  case clang::Type::Pointer:
3574  pointee_qual_type =
3575  llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
3576  success = true;
3577  break;
3578 
3579  case clang::Type::LValueReference:
3580  case clang::Type::RValueReference:
3581  pointee_qual_type =
3582  llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
3583  success = true;
3584  break;
3585 
3586  default:
3587  break;
3588  }
3589 
3590  if (success) {
3591  // Check to make sure what we are pointing too is a possible dynamic C++
3592  // type We currently accept any "void *" (in case we have a class that
3593  // has been watered down to an opaque pointer) and virtual C++ classes.
3594  const clang::Type::TypeClass pointee_type_class =
3595  pointee_qual_type.getCanonicalType()->getTypeClass();
3596  switch (pointee_type_class) {
3597  case clang::Type::Builtin:
3598  switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) {
3599  case clang::BuiltinType::UnknownAny:
3600  case clang::BuiltinType::Void:
3601  if (dynamic_pointee_type)
3602  dynamic_pointee_type->SetCompilerType(
3603  this, pointee_qual_type.getAsOpaquePtr());
3604  return true;
3605  default:
3606  break;
3607  }
3608  break;
3609 
3610  case clang::Type::Record:
3611  if (check_cplusplus) {
3612  clang::CXXRecordDecl *cxx_record_decl =
3613  pointee_qual_type->getAsCXXRecordDecl();
3614  if (cxx_record_decl) {
3615  bool is_complete = cxx_record_decl->isCompleteDefinition();
3616 
3617  if (is_complete)
3618  success = cxx_record_decl->isDynamicClass();
3619  else {
3620  ClangASTMetadata *metadata = GetMetadata(cxx_record_decl);
3621  if (metadata)
3622  success = metadata->GetIsDynamicCXXType();
3623  else {
3624  is_complete = GetType(pointee_qual_type).GetCompleteType();
3625  if (is_complete)
3626  success = cxx_record_decl->isDynamicClass();
3627  else
3628  success = false;
3629  }
3630  }
3631 
3632  if (success) {
3633  if (dynamic_pointee_type)
3634  dynamic_pointee_type->SetCompilerType(
3635  this, pointee_qual_type.getAsOpaquePtr());
3636  return true;
3637  }
3638  }
3639  }
3640  break;
3641 
3642  case clang::Type::ObjCObject:
3643  case clang::Type::ObjCInterface:
3644  if (check_objc) {
3645  if (dynamic_pointee_type)
3646  dynamic_pointee_type->SetCompilerType(
3647  this, pointee_qual_type.getAsOpaquePtr());
3648  return true;
3649  }
3650  break;
3651 
3652  default:
3653  break;
3654  }
3655  }
3656  }
3657  if (dynamic_pointee_type)
3658  dynamic_pointee_type->Clear();
3659  return false;
3660 }
3661 
3663  if (!type)
3664  return false;
3665 
3666  return (GetTypeInfo(type, nullptr) & eTypeIsScalar) != 0;
3667 }
3668 
3670  if (!type)
3671  return false;
3672  return RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef})
3673  ->getTypeClass() == clang::Type::Typedef;
3674 }
3675 
3677  if (!type)
3678  return false;
3679  return GetCanonicalQualType(type)->isVoidType();
3680 }
3681 
3683  if (auto *record_decl =
3685  return record_decl->canPassInRegisters();
3686  }
3687  return false;
3688 }
3689 
3691  return TypeSystemClangSupportsLanguage(language);
3692 }
3693 
3694 Optional<std::string>
3696  if (!type)
3697  return llvm::None;
3698 
3699  clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3700  if (qual_type.isNull())
3701  return llvm::None;
3702 
3703  clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3704  if (!cxx_record_decl)
3705  return llvm::None;
3706 
3707  return std::string(cxx_record_decl->getIdentifier()->getNameStart());
3708 }
3709 
3711  if (!type)
3712  return false;
3713 
3714  clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3715  return !qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr;
3716 }
3717 
3719  if (!type)
3720  return false;
3721  clang::QualType qual_type(GetCanonicalQualType(type));
3722  const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
3723  if (tag_type)
3724  return tag_type->isBeingDefined();
3725  return false;
3726 }
3727 
3729  CompilerType *class_type_ptr) {
3730  if (!ClangUtil::IsClangType(type))
3731  return false;
3732 
3733  clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3734 
3735  if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) {
3736  if (class_type_ptr) {
3737  if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) {
3738  const clang::ObjCObjectPointerType *obj_pointer_type =
3739  llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3740  if (obj_pointer_type == nullptr)
3741  class_type_ptr->Clear();
3742  else
3743  class_type_ptr->SetCompilerType(
3744  type.GetTypeSystem(),
3745  clang::QualType(obj_pointer_type->getInterfaceType(), 0)
3746  .getAsOpaquePtr());
3747  }
3748  }
3749  return true;
3750  }
3751  if (class_type_ptr)
3752  class_type_ptr->Clear();
3753  return false;
3754 }
3755 
3756 // Type Completion
3757 
3759  if (!type)
3760  return false;
3761  const bool allow_completion = true;
3763  allow_completion);
3764 }
3765 
3767  if (!type)
3768  return ConstString();
3769 
3770  clang::QualType qual_type(GetQualType(type));
3771 
3772  // Remove certain type sugar from the name. Sugar such as elaborated types
3773  // or template types which only serve to improve diagnostics shouldn't
3774  // act as their own types from the user's perspective (e.g., formatter
3775  // shouldn't format a variable differently depending on how the ser has
3776  // specified the type. '::Type' and 'Type' should behave the same).
3777  // Typedefs and atomic derived types are not removed as they are actually
3778  // useful for identifiying specific types.
3779  qual_type = RemoveWrappingTypes(qual_type,
3780  {clang::Type::Typedef, clang::Type::Atomic});
3781 
3782  // For a typedef just return the qualified name.
3783  if (const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
3784  const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
3785  return ConstString(GetTypeNameForDecl(typedef_decl));
3786  }
3787 
3788  return ConstString(qual_type.getAsString(GetTypePrintingPolicy()));
3789 }
3790 
3793  if (!type)
3794  return ConstString();
3795 
3796  clang::QualType qual_type(GetQualType(type));
3797  clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
3798  printing_policy.SuppressTagKeyword = true;
3799  printing_policy.SuppressScope = false;
3800  printing_policy.SuppressUnwrittenScope = true;
3801  printing_policy.SuppressInlineNamespace = true;
3802  return ConstString(qual_type.getAsString(printing_policy));
3803 }
3804 
3805 uint32_t
3807  CompilerType *pointee_or_element_clang_type) {
3808  if (!type)
3809  return 0;
3810 
3811  if (pointee_or_element_clang_type)
3812  pointee_or_element_clang_type->Clear();
3813 
3814  clang::QualType qual_type =
3815  RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
3816 
3817  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3818  switch (type_class) {
3819  case clang::Type::Attributed:
3820  return GetTypeInfo(
3821  qual_type->getAs<clang::AttributedType>()
3822  ->getModifiedType().getAsOpaquePtr(),
3823  pointee_or_element_clang_type);
3824  case clang::Type::Builtin: {
3825  const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(
3826  qual_type->getCanonicalTypeInternal());
3827 
3828  uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
3829  switch (builtin_type->getKind()) {
3830  case clang::BuiltinType::ObjCId:
3831  case clang::BuiltinType::ObjCClass:
3832  if (pointee_or_element_clang_type)
3833  pointee_or_element_clang_type->SetCompilerType(
3834  this, getASTContext().ObjCBuiltinClassTy.getAsOpaquePtr());
3835  builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3836  break;
3837 
3838  case clang::BuiltinType::ObjCSel:
3839  if (pointee_or_element_clang_type)
3840  pointee_or_element_clang_type->SetCompilerType(
3841  this, getASTContext().CharTy.getAsOpaquePtr());
3842  builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3843  break;
3844 
3845  case clang::BuiltinType::Bool:
3846  case clang::BuiltinType::Char_U:
3847  case clang::BuiltinType::UChar:
3848  case clang::BuiltinType::WChar_U:
3849  case clang::BuiltinType::Char16:
3850  case clang::BuiltinType::Char32:
3851  case clang::BuiltinType::UShort:
3853  case clang::BuiltinType::ULong:
3854  case clang::BuiltinType::ULongLong:
3855  case clang::BuiltinType::UInt128:
3856  case clang::BuiltinType::Char_S:
3857  case clang::BuiltinType::SChar:
3858  case clang::BuiltinType::WChar_S:
3859  case clang::BuiltinType::Short:
3860  case clang::BuiltinType::Int:
3861  case clang::BuiltinType::Long:
3862  case clang::BuiltinType::LongLong:
3863  case clang::BuiltinType::Int128:
3864  case clang::BuiltinType::Float:
3865  case clang::BuiltinType::Double:
3866  case clang::BuiltinType::LongDouble:
3867  builtin_type_flags |= eTypeIsScalar;
3868  if (builtin_type->isInteger()) {
3869  builtin_type_flags |= eTypeIsInteger;
3870  if (builtin_type->isSignedInteger())
3871  builtin_type_flags |= eTypeIsSigned;
3872  } else if (builtin_type->isFloatingPoint())
3873  builtin_type_flags |= eTypeIsFloat;
3874  break;
3875  default:
3876  break;
3877  }
3878  return builtin_type_flags;
3879  }
3880 
3881  case clang::Type::BlockPointer:
3882  if (pointee_or_element_clang_type)
3883  pointee_or_element_clang_type->SetCompilerType(
3884  this, qual_type->getPointeeType().getAsOpaquePtr());
3885  return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
3886 
3887  case clang::Type::Complex: {
3888  uint32_t complex_type_flags =
3889  eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
3890  const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(
3891  qual_type->getCanonicalTypeInternal());
3892  if (complex_type) {
3893  clang::QualType complex_element_type(complex_type->getElementType());
3894  if (complex_element_type->isIntegerType())
3895  complex_type_flags |= eTypeIsFloat;
3896  else if (complex_element_type->isFloatingType())
3897  complex_type_flags |= eTypeIsInteger;
3898  }
3899  return complex_type_flags;
3900  } break;
3901 
3902  case clang::Type::ConstantArray:
3903  case clang::Type::DependentSizedArray:
3904  case clang::Type::IncompleteArray:
3905  case clang::Type::VariableArray:
3906  if (pointee_or_element_clang_type)
3907  pointee_or_element_clang_type->SetCompilerType(
3908  this, llvm::cast<clang::ArrayType>(qual_type.getTypePtr())
3909  ->getElementType()
3910  .getAsOpaquePtr());
3911  return eTypeHasChildren | eTypeIsArray;
3912 
3913  case clang::Type::DependentName:
3914  return 0;
3915  case clang::Type::DependentSizedExtVector:
3916  return eTypeHasChildren | eTypeIsVector;
3917  case clang::Type::DependentTemplateSpecialization:
3918  return eTypeIsTemplate;
3919 
3920  case clang::Type::Enum:
3921  if (pointee_or_element_clang_type)
3922  pointee_or_element_clang_type->SetCompilerType(
3923  this, llvm::cast<clang::EnumType>(qual_type)
3924  ->getDecl()
3925  ->getIntegerType()
3926  .getAsOpaquePtr());
3927  return eTypeIsEnumeration | eTypeHasValue;
3928 
3929  case clang::Type::FunctionProto:
3930  return eTypeIsFuncPrototype | eTypeHasValue;
3931  case clang::Type::FunctionNoProto:
3932  return eTypeIsFuncPrototype | eTypeHasValue;
3933  case clang::Type::InjectedClassName:
3934  return 0;
3935 
3936  case clang::Type::LValueReference:
3937  case clang::Type::RValueReference:
3938  if (pointee_or_element_clang_type)
3939  pointee_or_element_clang_type->SetCompilerType(
3940  this, llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())
3941  ->getPointeeType()
3942  .getAsOpaquePtr());
3943  return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
3944 
3945  case clang::Type::MemberPointer:
3946  return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
3947 
3948  case clang::Type::ObjCObjectPointer:
3949  if (pointee_or_element_clang_type)
3950  pointee_or_element_clang_type->SetCompilerType(
3951  this, qual_type->getPointeeType().getAsOpaquePtr());
3952  return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer |
3953  eTypeHasValue;
3954 
3955  case clang::Type::ObjCObject:
3956  return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3957  case clang::Type::ObjCInterface:
3958  return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3959 
3960  case clang::Type::Pointer:
3961  if (pointee_or_element_clang_type)
3962  pointee_or_element_clang_type->SetCompilerType(
3963  this, qual_type->getPointeeType().getAsOpaquePtr());
3964  return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
3965 
3966  case clang::Type::Record:
3967  if (qual_type->getAsCXXRecordDecl())
3968  return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
3969  else
3970  return eTypeHasChildren | eTypeIsStructUnion;
3971  break;
3972  case clang::Type::SubstTemplateTypeParm:
3973  return eTypeIsTemplate;
3974  case clang::Type::TemplateTypeParm:
3975  return eTypeIsTemplate;
3976  case clang::Type::TemplateSpecialization:
3977  return eTypeIsTemplate;
3978 
3979  case clang::Type::Typedef:
3980  return eTypeIsTypedef | GetType(llvm::cast<clang::TypedefType>(qual_type)
3981  ->getDecl()
3982  ->getUnderlyingType())
3983  .GetTypeInfo(pointee_or_element_clang_type);
3984  case clang::Type::UnresolvedUsing:
3985  return 0;
3986 
3987  case clang::Type::ExtVector:
3988  case clang::Type::Vector: {
3989  uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
3990  const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
3991  qual_type->getCanonicalTypeInternal());
3992  if (vector_type) {
3993  if (vector_type->isIntegerType())
3994  vector_type_flags |= eTypeIsFloat;
3995  else if (vector_type->isFloatingType())
3996  vector_type_flags |= eTypeIsInteger;
3997  }
3998  return vector_type_flags;
3999  }
4000  default:
4001  return 0;
4002  }
4003  return 0;
4004 }
4005 
4008  if (!type)
4009  return lldb::eLanguageTypeC;
4010 
4011  // If the type is a reference, then resolve it to what it refers to first:
4012  clang::QualType qual_type(GetCanonicalQualType(type).getNonReferenceType());
4013  if (qual_type->isAnyPointerType()) {
4014  if (qual_type->isObjCObjectPointerType())
4015  return lldb::eLanguageTypeObjC;
4016  if (qual_type->getPointeeCXXRecordDecl())
4018 
4019  clang::QualType pointee_type(qual_type->getPointeeType());
4020  if (pointee_type->getPointeeCXXRecordDecl())
4022  if (pointee_type->isObjCObjectOrInterfaceType())
4023  return lldb::eLanguageTypeObjC;
4024  if (pointee_type->isObjCClassType())
4025  return lldb::eLanguageTypeObjC;
4026  if (pointee_type.getTypePtr() ==
4027  getASTContext().ObjCBuiltinIdTy.getTypePtr())
4028  return lldb::eLanguageTypeObjC;
4029  } else {
4030  if (qual_type->isObjCObjectOrInterfaceType())
4031  return lldb::eLanguageTypeObjC;
4032  if (qual_type->getAsCXXRecordDecl())
4034  switch (qual_type->getTypeClass()) {
4035  default:
4036  break;
4037  case clang::Type::Builtin:
4038  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4039  default:
4040  case clang::BuiltinType::Void:
4041  case clang::BuiltinType::Bool:
4042  case clang::BuiltinType::Char_U:
4043  case clang::BuiltinType::UChar:
4044  case clang::BuiltinType::WChar_U:
4045  case clang::BuiltinType::Char16:
4046  case clang::BuiltinType::Char32:
4047  case clang::BuiltinType::UShort:
4049  case clang::BuiltinType::ULong:
4050  case clang::BuiltinType::ULongLong:
4051  case clang::BuiltinType::UInt128:
4052  case clang::BuiltinType::Char_S:
4053  case clang::BuiltinType::SChar:
4054  case clang::BuiltinType::WChar_S:
4055  case clang::BuiltinType::Short:
4056  case clang::BuiltinType::Int:
4057  case clang::BuiltinType::Long:
4058  case clang::BuiltinType::LongLong:
4059  case clang::BuiltinType::Int128:
4060  case clang::BuiltinType::Float:
4061  case clang::BuiltinType::Double:
4062  case clang::BuiltinType::LongDouble:
4063  break;
4064 
4065  case clang::BuiltinType::NullPtr:
4066  return eLanguageTypeC_plus_plus;
4067 
4068  case clang::BuiltinType::ObjCId:
4069  case clang::BuiltinType::ObjCClass:
4070  case clang::BuiltinType::ObjCSel:
4071  return eLanguageTypeObjC;
4072 
4073  case clang::BuiltinType::Dependent:
4074  case clang::BuiltinType::Overload:
4075  case clang::BuiltinType::BoundMember:
4076  case clang::BuiltinType::UnknownAny:
4077  break;
4078  }
4079  break;
4080  case clang::Type::Typedef:
4081  return GetType(llvm::cast<clang::TypedefType>(qual_type)
4082  ->getDecl()
4083  ->getUnderlyingType())
4084  .GetMinimumLanguage();
4085  }
4086  }
4087  return lldb::eLanguageTypeC;
4088 }
4089 
4090 lldb::TypeClass
4092  if (!type)
4093  return lldb::eTypeClassInvalid;
4094 
4095  clang::QualType qual_type =
4096  RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
4097 
4098  switch (qual_type->getTypeClass()) {
4099  case clang::Type::Atomic:
4100  case clang::Type::Auto:
4101  case clang::Type::Decltype:
4102  case clang::Type::Elaborated:
4103  case clang::Type::Paren:
4104  case clang::Type::TypeOf:
4105  case clang::Type::TypeOfExpr:
4106  case clang::Type::Using:
4107  llvm_unreachable("Handled in RemoveWrappingTypes!");
4108  case clang::Type::UnaryTransform:
4109  break;
4110  case clang::Type::FunctionNoProto:
4111  return lldb::eTypeClassFunction;
4112  case clang::Type::FunctionProto:
4113  return lldb::eTypeClassFunction;
4114  case clang::Type::IncompleteArray:
4115  return lldb::eTypeClassArray;
4116  case clang::Type::VariableArray:
4117  return lldb::eTypeClassArray;
4118  case clang::Type::ConstantArray:
4119  return lldb::eTypeClassArray;
4120  case clang::Type::DependentSizedArray:
4121  return lldb::eTypeClassArray;
4122  case clang::Type::DependentSizedExtVector:
4123  return lldb::eTypeClassVector;
4124  case clang::Type::DependentVector:
4125  return lldb::eTypeClassVector;
4126  case clang::Type::ExtVector:
4127  return lldb::eTypeClassVector;
4128  case clang::Type::Vector:
4129  return lldb::eTypeClassVector;
4130  case clang::Type::Builtin:
4131  // Ext-Int is just an integer type.
4132  case clang::Type::BitInt:
4133  case clang::Type::DependentBitInt:
4134  return lldb::eTypeClassBuiltin;
4135  case clang::Type::ObjCObjectPointer:
4136  return lldb::eTypeClassObjCObjectPointer;
4137  case clang::Type::BlockPointer:
4138  return lldb::eTypeClassBlockPointer;
4139  case clang::Type::Pointer:
4140  return lldb::eTypeClassPointer;
4141  case clang::Type::LValueReference:
4142  return lldb::eTypeClassReference;
4143  case clang::Type::RValueReference:
4144  return lldb::eTypeClassReference;
4145  case clang::Type::MemberPointer:
4146  return lldb::eTypeClassMemberPointer;
4147  case clang::Type::Complex:
4148  if (qual_type->isComplexType())
4149  return lldb::eTypeClassComplexFloat;
4150  else
4151  return lldb::eTypeClassComplexInteger;
4152  case clang::Type::ObjCObject:
4153  return lldb::eTypeClassObjCObject;
4154  case clang::Type::ObjCInterface:
4155  return lldb::eTypeClassObjCInterface;
4156  case clang::Type::Record: {
4157  const clang::RecordType *record_type =
4158  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4159  const clang::RecordDecl *record_decl = record_type->getDecl();
4160  if (record_decl->isUnion())
4161  return lldb::eTypeClassUnion;
4162  else if (record_decl->isStruct())
4163  return lldb::eTypeClassStruct;
4164  else
4165  return lldb::eTypeClassClass;
4166  } break;
4167  case clang::Type::Enum:
4168  return lldb::eTypeClassEnumeration;
4169  case clang::Type::Typedef:
4170  return lldb::eTypeClassTypedef;
4171  case clang::Type::UnresolvedUsing:
4172  break;
4173 
4174  case clang::Type::Attributed:
4175  break;
4176  case clang::Type::TemplateTypeParm:
4177  break;
4178  case clang::Type::SubstTemplateTypeParm:
4179  break;
4180  case clang::Type::SubstTemplateTypeParmPack:
4181  break;
4182  case clang::Type::InjectedClassName:
4183  break;
4184  case clang::Type::DependentName:
4185  break;
4186  case clang::Type::DependentTemplateSpecialization:
4187  break;
4188  case clang::Type::PackExpansion:
4189  break;
4190 
4191  case clang::Type::TemplateSpecialization:
4192  break;
4193  case clang::Type::DeducedTemplateSpecialization:
4194  break;
4195  case clang::Type::Pipe:
4196  break;
4197 
4198  // pointer type decayed from an array or function type.
4199  case clang::Type::Decayed:
4200  break;
4201  case clang::Type::Adjusted:
4202  break;
4203  case clang::Type::ObjCTypeParam:
4204  break;
4205 
4206  case clang::Type::DependentAddressSpace:
4207  break;
4208  case clang::Type::MacroQualified:
4209  break;
4210 
4211  // Matrix types that we're not sure how to display at the moment.
4212  case clang::Type::ConstantMatrix:
4213  case clang::Type::DependentSizedMatrix:
4214  break;
4215  }
4216  // We don't know hot to display this type...
4217  return lldb::eTypeClassOther;
4218 }
4219 
4221  if (type)
4222  return GetQualType(type).getQualifiers().getCVRQualifiers();
4223  return 0;
4224 }
4225 
4226 // Creating related types
4227 
4230  ExecutionContextScope *exe_scope) {
4231  if (type) {
4232  clang::QualType qual_type(GetQualType(type));
4233 
4234  const clang::Type *array_eletype =
4235  qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
4236 
4237  if (!array_eletype)
4238  return CompilerType();
4239 
4240  return GetType(clang::QualType(array_eletype, 0));
4241  }
4242  return CompilerType();
4243 }
4244 
4246  uint64_t size) {
4247  if (type) {
4248  clang::QualType qual_type(GetCanonicalQualType(type));
4249  clang::ASTContext &ast_ctx = getASTContext();
4250  if (size != 0)
4251  return GetType(ast_ctx.getConstantArrayType(
4252  qual_type, llvm::APInt(64, size), nullptr,
4253  clang::ArrayType::ArraySizeModifier::Normal, 0));
4254  else
4255  return GetType(ast_ctx.getIncompleteArrayType(
4256  qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
4257  }
4258 
4259  return CompilerType();
4260 }
4261 
4264  if (type)
4265  return GetType(GetCanonicalQualType(type));
4266  return CompilerType();
4267 }
4268 
4269 static clang::QualType GetFullyUnqualifiedType_Impl(clang::ASTContext *ast,
4270  clang::QualType qual_type) {
4271  if (qual_type->isPointerType())
4272  qual_type = ast->getPointerType(
4273  GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
4274  else if (const ConstantArrayType *arr =
4275  ast->getAsConstantArrayType(qual_type)) {
4276  qual_type = ast->getConstantArrayType(
4277  GetFullyUnqualifiedType_Impl(ast, arr->getElementType()),
4278  arr->getSize(), arr->getSizeExpr(), arr->getSizeModifier(),
4279  arr->getIndexTypeQualifiers().getAsOpaqueValue());
4280  } else
4281  qual_type = qual_type.getUnqualifiedType();
4282  qual_type.removeLocalConst();
4283  qual_type.removeLocalRestrict();
4284  qual_type.removeLocalVolatile();
4285  return qual_type;
4286 }
4287 
4290  if (type)
4291  return GetType(
4293  return CompilerType();
4294 }
4295 
4298  if (type)
4300  return CompilerType();
4301 }
4302 
4305  if (type) {
4306  const clang::FunctionProtoType *func =
4307  llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
4308  if (func)
4309  return func->getNumParams();
4310  }
4311  return -1;
4312 }
4313 
4315  lldb::opaque_compiler_type_t type, size_t idx) {
4316  if (type) {
4317  const clang::FunctionProtoType *func =
4318  llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type));
4319  if (func) {
4320  const uint32_t num_args = func->getNumParams();
4321  if (idx < num_args)
4322  return GetType(func->getParamType(idx));
4323  }
4324  }
4325  return CompilerType();
4326 }
4327 
4330  if (type) {
4331  clang::QualType qual_type(GetQualType(type));
4332  const clang::FunctionProtoType *func =
4333  llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
4334  if (func)
4335  return GetType(func->getReturnType());
4336  }
4337  return CompilerType();
4338 }
4339 
4340 size_t
4342  size_t num_functions = 0;
4343  if (type) {
4344  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
4345  switch (qual_type->getTypeClass()) {
4346  case clang::Type::Record:
4347  if (GetCompleteQualType(&getASTContext(), qual_type)) {
4348  const clang::RecordType *record_type =
4349  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4350  const clang::RecordDecl *record_decl = record_type->getDecl();
4351  assert(record_decl);
4352  const clang::CXXRecordDecl *cxx_record_decl =
4353  llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4354  if (cxx_record_decl)
4355  num_functions = std::distance(cxx_record_decl->method_begin(),
4356  cxx_record_decl->method_end());
4357  }
4358  break;
4359 
4360  case clang::Type::ObjCObjectPointer: {
4361  const clang::ObjCObjectPointerType *objc_class_type =
4362  qual_type->getAs<clang::ObjCObjectPointerType>();
4363  const clang::ObjCInterfaceType *objc_interface_type =
4364  objc_class_type->getInterfaceType();
4365  if (objc_interface_type &&
4367  const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
4368  clang::ObjCInterfaceDecl *class_interface_decl =
4369  objc_interface_type->getDecl();
4370  if (class_interface_decl) {
4371  num_functions = std::distance(class_interface_decl->meth_begin(),
4372  class_interface_decl->meth_end());
4373  }
4374  }
4375  break;
4376  }
4377 
4378  case clang::Type::ObjCObject:
4379  case clang::Type::ObjCInterface:
4380  if (GetCompleteType(type)) {
4381  const clang::ObjCObjectType *objc_class_type =
4382  llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4383  if (objc_class_type) {
4384  clang::ObjCInterfaceDecl *class_interface_decl =
4385  objc_class_type->getInterface();
4386  if (class_interface_decl)
4387  num_functions = std::distance(class_interface_decl->meth_begin(),
4388  class_interface_decl->meth_end());
4389  }
4390  }
4391  break;
4392 
4393  default:
4394  break;
4395  }
4396  }
4397  return num_functions;
4398 }
4399 
4402  size_t idx) {
4403  std::string name;
4405  CompilerType clang_type;
4406  CompilerDecl clang_decl;
4407  if (type) {
4408  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
4409  switch (qual_type->getTypeClass()) {
4410  case clang::Type::Record:
4411  if (GetCompleteQualType(&getASTContext(), qual_type)) {
4412  const clang::RecordType *record_type =
4413  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4414  const clang::RecordDecl *record_decl = record_type->getDecl();
4415  assert(record_decl);
4416  const clang::CXXRecordDecl *cxx_record_decl =
4417  llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4418  if (cxx_record_decl) {
4419  auto method_iter = cxx_record_decl->method_begin();
4420  auto method_end = cxx_record_decl->method_end();
4421  if (idx <
4422  static_cast<size_t>(std::distance(method_iter, method_end))) {
4423  std::advance(method_iter, idx);
4424  clang::CXXMethodDecl *cxx_method_decl =
4425  method_iter->getCanonicalDecl();
4426  if (cxx_method_decl) {
4427  name = cxx_method_decl->getDeclName().getAsString();
4428  if (cxx_method_decl->isStatic())
4430  else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl))
4432  else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl))
4434  else
4436  clang_type = GetType(cxx_method_decl->getType());
4437  clang_decl = GetCompilerDecl(cxx_method_decl);
4438  }
4439  }
4440  }
4441  }
4442  break;
4443 
4444  case clang::Type::ObjCObjectPointer: {
4445  const clang::ObjCObjectPointerType *objc_class_type =
4446  qual_type->getAs<clang::ObjCObjectPointerType>();
4447  const clang::ObjCInterfaceType *objc_interface_type =
4448  objc_class_type->getInterfaceType();
4449  if (objc_interface_type &&
4451  const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
4452  clang::ObjCInterfaceDecl *class_interface_decl =
4453  objc_interface_type->getDecl();
4454  if (class_interface_decl) {
4455  auto method_iter = class_interface_decl->meth_begin();
4456  auto method_end = class_interface_decl->meth_end();
4457  if (idx <
4458  static_cast<size_t>(std::distance(method_iter, method_end))) {
4459  std::advance(method_iter, idx);
4460  clang::ObjCMethodDecl *objc_method_decl =
4461  method_iter->getCanonicalDecl();
4462  if (objc_method_decl) {
4463  clang_decl = GetCompilerDecl(objc_method_decl);
4464  name = objc_method_decl->getSelector().getAsString();
4465  if (objc_method_decl->isClassMethod())
4467  else
4469  }
4470  }
4471  }
4472  }
4473  break;
4474  }
4475 
4476  case clang::Type::ObjCObject:
4477  case clang::Type::ObjCInterface:
4478  if (GetCompleteType(type)) {
4479  const clang::ObjCObjectType *objc_class_type =
4480  llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4481  if (objc_class_type) {
4482  clang::ObjCInterfaceDecl *class_interface_decl =
4483  objc_class_type->getInterface();
4484  if (class_interface_decl) {
4485  auto method_iter = class_interface_decl->meth_begin();
4486  auto method_end = class_interface_decl->meth_end();
4487  if (idx <
4488  static_cast<size_t>(std::distance(method_iter, method_end))) {
4489  std::advance(method_iter, idx);
4490  clang::ObjCMethodDecl *objc_method_decl =
4491  method_iter->getCanonicalDecl();
4492  if (objc_method_decl) {
4493  clang_decl = GetCompilerDecl(objc_method_decl);
4494  name = objc_method_decl->getSelector().getAsString();
4495  if (objc_method_decl->isClassMethod())
4497  else
4499  }
4500  }
4501  }
4502  }
4503  }
4504  break;
4505 
4506  default:
4507  break;
4508  }
4509  }
4510 
4511  if (kind == eMemberFunctionKindUnknown)
4512  return TypeMemberFunctionImpl();
4513  else
4514  return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind);
4515 }
4516 
4519  if (type)
4520  return GetType(GetQualType(type).getNonReferenceType());
4521  return CompilerType();
4522 }
4523 
4526  if (type) {
4527  clang::QualType qual_type(GetQualType(type));
4528  return GetType(qual_type.getTypePtr()->getPointeeType());
4529  }
4530  return CompilerType();
4531 }
4532 
4535  if (type) {
4536  clang::QualType qual_type(GetQualType(type));
4537 
4538  switch (qual_type.getDesugaredType(getASTContext())->getTypeClass()) {
4539  case clang::Type::ObjCObject:
4540  case clang::Type::ObjCInterface:
4541  return GetType(getASTContext().getObjCObjectPointerType(qual_type));
4542 
4543  default:
4544  return GetType(getASTContext().getPointerType(qual_type));
4545  }
4546  }
4547  return CompilerType();
4548 }
4549 
4552  if (type)
4553  return GetType(getASTContext().getLValueReferenceType(GetQualType(type)));
4554  else
4555  return CompilerType();
4556 }
4557 
4560  if (type)
4561  return GetType(getASTContext().getRValueReferenceType(GetQualType(type)));
4562  else
4563  return CompilerType();
4564 }
4565 
4567  if (!type)
4568  return CompilerType();
4569  return GetType(getASTContext().getAtomicType(GetQualType(type)));
4570 }
4571 
4574  if (type) {
4575  clang::QualType result(GetQualType(type));
4576  result.addConst();
4577  return GetType(result);
4578  }
4579  return CompilerType();
4580 }
4581 
4584  if (type) {
4585  clang::QualType result(GetQualType(type));
4586  result.addVolatile();
4587  return GetType(result);
4588  }
4589  return CompilerType();
4590 }
4591 
4594  if (type) {
4595  clang::QualType result(GetQualType(type));
4596  result.addRestrict();
4597  return GetType(result);
4598  }
4599  return CompilerType();
4600 }
4601 
4603  lldb::opaque_compiler_type_t type, const char *typedef_name,
4604  const CompilerDeclContext &compiler_decl_ctx, uint32_t payload) {
4605  if (type && typedef_name && typedef_name[0]) {
4606  clang::ASTContext &clang_ast = getASTContext();
4607  clang::QualType qual_type(GetQualType(type));
4608 
4609  clang::DeclContext *decl_ctx =
4611  if (!decl_ctx)
4612  decl_ctx = getASTContext().getTranslationUnitDecl();
4613 
4614  clang::TypedefDecl *decl =
4615  clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
4616  decl->setDeclContext(decl_ctx);
4617  decl->setDeclName(&clang_ast.Idents.get(typedef_name));
4618  decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
4619  decl_ctx->addDecl(decl);
4620  SetOwningModule(decl, TypePayloadClang(payload).GetOwningModule());
4621 
4622  clang::TagDecl *tdecl = nullptr;
4623  if (!qual_type.isNull()) {
4624  if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
4625  tdecl = rt->getDecl();
4626  if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
4627  tdecl = et->getDecl();
4628  }
4629 
4630  // Check whether this declaration is an anonymous struct, union, or enum,
4631  // hidden behind a typedef. If so, we try to check whether we have a
4632  // typedef tag to attach to the original record declaration
4633  if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
4634  tdecl->setTypedefNameForAnonDecl(decl);
4635 
4636  decl->setAccess(clang::AS_public); // TODO respect proper access specifier
4637 
4638  // Get a uniqued clang::QualType for the typedef decl type
4639  return GetType(clang_ast.getTypedefType(decl));
4640  }
4641  return CompilerType();
4642 }
4643 
4646  if (type) {
4647  const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(
4648  RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef}));
4649  if (typedef_type)
4650  return GetType(typedef_type->getDecl()->getUnderlyingType());
4651  }
4652  return CompilerType();
4653 }
4654 
4655 // Create related types using the current type's AST
4656 
4658  return TypeSystemClang::GetBasicType(basic_type);
4659 }
4660 // Exploring the type
4661 
4662 const llvm::fltSemantics &
4664  clang::ASTContext &ast = getASTContext();
4665  const size_t bit_size = byte_size * 8;
4666  if (bit_size == ast.getTypeSize(ast.FloatTy))
4667  return ast.getFloatTypeSemantics(ast.FloatTy);
4668  else if (bit_size == ast.getTypeSize(ast.DoubleTy))
4669  return ast.getFloatTypeSemantics(ast.DoubleTy);
4670  else if (bit_size == ast.getTypeSize(ast.LongDoubleTy))
4671  return ast.getFloatTypeSemantics(ast.LongDoubleTy);
4672  else if (bit_size == ast.getTypeSize(ast.HalfTy))
4673  return ast.getFloatTypeSemantics(ast.HalfTy);
4674  return llvm::APFloatBase::Bogus();
4675 }
4676 
4677 Optional<uint64_t>
4679  ExecutionContextScope *exe_scope) {
4680  if (GetCompleteType(type)) {
4681  clang::QualType qual_type(GetCanonicalQualType(type));
4682  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4683  switch (type_class) {
4684  case clang::Type::Record:
4685  if (GetCompleteType(type))
4686  return getASTContext().getTypeSize(qual_type);
4687  else
4688  return None;
4689  break;
4690 
4691  case clang::Type::ObjCInterface:
4692  case clang::Type::ObjCObject: {
4693  ExecutionContext exe_ctx(exe_scope);
4694  Process *process = exe_ctx.GetProcessPtr();
4695  if (process) {
4696  ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
4697  if (objc_runtime) {
4698  uint64_t bit_size = 0;
4699  if (objc_runtime->GetTypeBitSize(GetType(qual_type), bit_size))
4700  return bit_size;
4701  }
4702  } else {
4703  static bool g_printed = false;
4704  if (!g_printed) {
4705  StreamString s;
4706  DumpTypeDescription(type, &s);
4707 
4708  llvm::outs() << "warning: trying to determine the size of type ";
4709  llvm::outs() << s.GetString() << "\n";
4710  llvm::outs() << "without a valid ExecutionContext. this is not "
4711  "reliable. please file a bug against LLDB.\n";
4712  llvm::outs() << "backtrace:\n";
4713  llvm::sys::PrintStackTrace(llvm::outs());
4714  llvm::outs() << "\n";
4715  g_printed = true;
4716  }
4717  }
4718  }
4719  LLVM_FALLTHROUGH;
4720  default:
4721  const uint32_t bit_size = getASTContext().getTypeSize(qual_type);
4722  if (bit_size == 0) {
4723  if (qual_type->isIncompleteArrayType())
4724  return getASTContext().getTypeSize(
4725  qual_type->getArrayElementTypeNoTypeQual()
4726  ->getCanonicalTypeUnqualified());
4727  }
4728  if (qual_type->isObjCObjectOrInterfaceType())
4729  return bit_size +
4730  getASTContext().getTypeSize(getASTContext().ObjCBuiltinClassTy);
4731  // Function types actually have a size of 0, that's not an error.
4732  if (qual_type->isFunctionProtoType())
4733  return bit_size;
4734  if (bit_size)
4735  return bit_size;
4736  }
4737  }
4738  return None;
4739 }
4740 
4741 llvm::Optional<size_t>
4743  ExecutionContextScope *exe_scope) {
4744  if (GetCompleteType(type))
4745  return getASTContext().getTypeAlign(GetQualType(type));
4746  return {};
4747 }
4748 
4750  uint64_t &count) {
4751  if (!type)
4752  return lldb::eEncodingInvalid;
4753 
4754  count = 1;
4755  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
4756 
4757  switch (qual_type->getTypeClass()) {
4758  case clang::Type::Atomic:
4759  case clang::Type::Auto:
4760  case clang::Type::Decltype:
4761  case clang::Type::Elaborated:
4762  case clang::Type::Paren:
4763  case clang::Type::Typedef:
4764  case clang::Type::TypeOf:
4765  case clang::Type::TypeOfExpr:
4766  case clang::Type::Using:
4767  llvm_unreachable("Handled in RemoveWrappingTypes!");
4768 
4769  case clang::Type::UnaryTransform:
4770  break;
4771 
4772  case clang::Type::FunctionNoProto:
4773  case clang::Type::FunctionProto:
4774  break;
4775 
4776  case clang::Type::IncompleteArray:
4777  case clang::Type::VariableArray:
4778  break;
4779 
4780  case clang::Type::ConstantArray:
4781  break;
4782 
4783  case clang::Type::DependentVector:
4784  case clang::Type::ExtVector:
4785  case clang::Type::Vector:
4786  // TODO: Set this to more than one???
4787  break;
4788 
4789  case clang::Type::BitInt:
4790  case clang::Type::DependentBitInt:
4791  return qual_type->isUnsignedIntegerType() ? lldb::eEncodingUint
4793 
4794  case clang::Type::Builtin:
4795  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4796  case clang::BuiltinType::Void:
4797  break;
4798 
4799  case clang::BuiltinType::Char_S:
4800  case clang::BuiltinType::SChar:
4801  case clang::BuiltinType::WChar_S:
4802  case clang::BuiltinType::Short:
4803  case clang::BuiltinType::Int:
4804  case clang::BuiltinType::Long:
4805  case clang::BuiltinType::LongLong:
4806  case clang::BuiltinType::Int128:
4807  return lldb::eEncodingSint;
4808 
4809  case clang::BuiltinType::Bool:
4810  case clang::BuiltinType::Char_U:
4811  case clang::BuiltinType::UChar:
4812  case clang::BuiltinType::WChar_U:
4813  case clang::BuiltinType::Char8:
4814  case clang::BuiltinType::Char16:
4815  case clang::BuiltinType::Char32:
4816  case clang::BuiltinType::UShort:
4818  case clang::BuiltinType::ULong:
4819  case clang::BuiltinType::ULongLong:
4820  case clang::BuiltinType::UInt128:
4821  return lldb::eEncodingUint;
4822 
4823  // Fixed point types. Note that they are currently ignored.
4824  case clang::BuiltinType::ShortAccum:
4825  case clang::BuiltinType::Accum:
4826  case clang::BuiltinType::LongAccum:
4827  case clang::BuiltinType::UShortAccum:
4828  case clang::BuiltinType::UAccum:
4829  case clang::BuiltinType::ULongAccum:
4830  case clang::BuiltinType::ShortFract:
4831  case clang::BuiltinType::Fract:
4832  case clang::BuiltinType::LongFract:
4833  case clang::BuiltinType::UShortFract:
4834  case clang::BuiltinType::UFract:
4835  case clang::BuiltinType::ULongFract:
4836  case clang::BuiltinType::SatShortAccum:
4837  case clang::BuiltinType::SatAccum:
4838  case clang::BuiltinType::SatLongAccum:
4839  case clang::BuiltinType::SatUShortAccum:
4840  case clang::BuiltinType::SatUAccum:
4841  case clang::BuiltinType::SatULongAccum:
4842  case clang::BuiltinType::SatShortFract:
4843  case clang::BuiltinType::SatFract:
4844  case clang::BuiltinType::SatLongFract:
4845  case clang::BuiltinType::SatUShortFract:
4846  case clang::BuiltinType::SatUFract:
4847  case clang::BuiltinType::SatULongFract:
4848  break;
4849 
4850  case clang::BuiltinType::Half:
4851  case clang::BuiltinType::Float:
4852  case clang::BuiltinType::Float16:
4853  case clang::BuiltinType::Float128:
4854  case clang::BuiltinType::Double:
4855  case clang::BuiltinType::LongDouble:
4856  case clang::BuiltinType::BFloat16:
4857  case clang::BuiltinType::Ibm128:
4858  return lldb::eEncodingIEEE754;
4859 
4860  case clang::BuiltinType::ObjCClass:
4861  case clang::BuiltinType::ObjCId:
4862  case clang::BuiltinType::ObjCSel:
4863  return lldb::eEncodingUint;
4864 
4865  case clang::BuiltinType::NullPtr:
4866  return lldb::eEncodingUint;
4867 
4868  case clang::BuiltinType::Kind::ARCUnbridgedCast:
4869  case clang::BuiltinType::Kind::BoundMember:
4870  case clang::BuiltinType::Kind::BuiltinFn:
4871  case clang::BuiltinType::Kind::Dependent:
4872  case clang::BuiltinType::Kind::OCLClkEvent:
4873  case clang::BuiltinType::Kind::OCLEvent:
4874  case clang::BuiltinType::Kind::OCLImage1dRO:
4875  case clang::BuiltinType::Kind::OCLImage1dWO:
4876  case clang::BuiltinType::Kind::OCLImage1dRW:
4877  case clang::BuiltinType::Kind::OCLImage1dArrayRO:
4878  case clang::BuiltinType::Kind::OCLImage1dArrayWO:
4879  case clang::BuiltinType::Kind::OCLImage1dArrayRW:
4880  case clang::BuiltinType::Kind::OCLImage1dBufferRO:
4881  case clang::BuiltinType::Kind::OCLImage1dBufferWO:
4882  case clang::BuiltinType::Kind::OCLImage1dBufferRW:
4883  case clang::BuiltinType::Kind::OCLImage2dRO:
4884  case clang::BuiltinType::Kind::OCLImage2dWO:
4885  case clang::BuiltinType::Kind::OCLImage2dRW:
4886  case clang::BuiltinType::Kind::OCLImage2dArrayRO:
4887  case clang::BuiltinType::Kind::OCLImage2dArrayWO:
4888  case clang::BuiltinType::Kind::OCLImage2dArrayRW:
4889  case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO:
4890  case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO:
4891  case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW:
4892  case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO:
4893  case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO:
4894  case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW:
4895  case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO:
4896  case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO:
4897  case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW:
4898  case clang::BuiltinType::Kind::OCLImage2dDepthRO:
4899  case clang::BuiltinType::Kind::OCLImage2dDepthWO:
4900  case clang::BuiltinType::Kind::OCLImage2dDepthRW:
4901  case clang::BuiltinType::Kind::OCLImage2dMSAARO:
4902  case clang::BuiltinType::Kind::OCLImage2dMSAAWO:
4903  case clang::BuiltinType::Kind::OCLImage2dMSAARW:
4904  case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO:
4905  case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO:
4906  case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW:
4907  case clang::BuiltinType::Kind::OCLImage3dRO:
4908  case clang::BuiltinType::Kind::OCLImage3dWO:
4909  case clang::BuiltinType::Kind::OCLImage3dRW:
4910  case clang::BuiltinType::Kind::OCLQueue:
4911  case clang::BuiltinType::Kind::OCLReserveID:
4912  case clang::BuiltinType::Kind::OCLSampler:
4913  case clang::BuiltinType::Kind::OMPArraySection:
4914  case clang::BuiltinType::Kind::OMPArrayShaping:
4915  case clang::BuiltinType::Kind::OMPIterator:
4916  case clang::BuiltinType::Kind::Overload:
4917  case clang::BuiltinType::Kind::PseudoObject:
4918  case clang::BuiltinType::Kind::UnknownAny:
4919  break;
4920 
4921  case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
4922  case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
4923  case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
4924  case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
4925  case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
4926  case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
4927  case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
4928  case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
4929  case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
4930  case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
4931  case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
4932  case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
4933  break;
4934 
4935  // PowerPC -- Matrix Multiply Assist
4936  case clang::BuiltinType::VectorPair:
4937  case clang::BuiltinType::VectorQuad:
4938  break;
4939 
4940  // ARM -- Scalable Vector Extension
4941  case clang::BuiltinType::SveBool:
4942  case clang::BuiltinType::SveInt8:
4943  case clang::BuiltinType::SveInt8x2:
4944  case clang::BuiltinType::SveInt8x3:
4945  case clang::BuiltinType::SveInt8x4:
4946  case clang::BuiltinType::SveInt16:
4947  case clang::BuiltinType::SveInt16x2:
4948  case clang::BuiltinType::SveInt16x3:
4949  case clang::BuiltinType::SveInt16x4:
4950  case clang::BuiltinType::SveInt32:
4951  case clang::BuiltinType::SveInt32x2:
4952  case clang::BuiltinType::SveInt32x3:
4953  case clang::BuiltinType::SveInt32x4:
4954  case clang::BuiltinType::SveInt64:
4955  case clang::BuiltinType::SveInt64x2:
4956  case clang::BuiltinType::SveInt64x3:
4957  case clang::BuiltinType::SveInt64x4:
4958  case clang::BuiltinType::SveUint8:
4959  case clang::BuiltinType::SveUint8x2:
4960  case clang::BuiltinType::SveUint8x3:
4961  case clang::BuiltinType::SveUint8x4:
4962  case clang::BuiltinType::SveUint16:
4963  case clang::BuiltinType::SveUint16x2:
4964  case clang::BuiltinType::SveUint16x3:
4965  case clang::BuiltinType::SveUint16x4:
4966  case clang::BuiltinType::SveUint32:
4967  case clang::BuiltinType::SveUint32x2:
4968  case clang::BuiltinType::SveUint32x3:
4969  case clang::BuiltinType::SveUint32x4:
4970  case clang::BuiltinType::SveUint64:
4971  case clang::BuiltinType::SveUint64x2:
4972  case clang::BuiltinType::SveUint64x3:
4973  case clang::BuiltinType::SveUint64x4:
4974  case clang::BuiltinType::SveFloat16:
4975  case clang::BuiltinType::SveBFloat16:
4976  case clang::BuiltinType::SveBFloat16x2:
4977  case clang::BuiltinType::SveBFloat16x3:
4978  case clang::BuiltinType::SveBFloat16x4:
4979  case clang::BuiltinType::SveFloat16x2:
4980  case clang::BuiltinType::SveFloat16x3:
4981  case clang::BuiltinType::SveFloat16x4:
4982  case clang::BuiltinType::SveFloat32:
4983  case clang::BuiltinType::SveFloat32x2:
4984  case clang::BuiltinType::SveFloat32x3:
4985  case clang::BuiltinType::SveFloat32x4:
4986  case clang::BuiltinType::SveFloat64:
4987  case clang::BuiltinType::SveFloat64x2:
4988  case clang::BuiltinType::SveFloat64x3:
4989  case clang::BuiltinType::SveFloat64x4:
4990  break;
4991 
4992  // RISC-V V builtin types.
4993  case clang::BuiltinType::RvvInt8mf8:
4994  case clang::BuiltinType::RvvInt8mf4:
4995  case clang::BuiltinType::RvvInt8mf2:
4996  case clang::BuiltinType::RvvInt8m1:
4997  case clang::BuiltinType::RvvInt8m2:
4998  case clang::BuiltinType::RvvInt8m4:
4999  case clang::BuiltinType::RvvInt8m8:
5000  case clang::BuiltinType::RvvUint8mf8:
5001  case clang::BuiltinType::RvvUint8mf4:
5002  case clang::BuiltinType::RvvUint8mf2:
5003  case clang::BuiltinType::RvvUint8m1:
5004  case clang::BuiltinType::RvvUint8m2:
5005  case clang::BuiltinType::RvvUint8m4:
5006  case clang::BuiltinType::RvvUint8m8:
5007  case clang::BuiltinType::RvvInt16mf4:
5008  case clang::BuiltinType::RvvInt16mf2:
5009  case clang::BuiltinType::RvvInt16m1:
5010  case clang::BuiltinType::RvvInt16m2:
5011  case clang::BuiltinType::RvvInt16m4:
5012  case clang::BuiltinType::RvvInt16m8:
5013  case clang::BuiltinType::RvvUint16mf4:
5014  case clang::BuiltinType::RvvUint16mf2:
5015  case clang::BuiltinType::RvvUint16m1:
5016  case clang::BuiltinType::RvvUint16m2:
5017  case clang::BuiltinType::RvvUint16m4:
5018  case clang::BuiltinType::RvvUint16m8:
5019  case clang::BuiltinType::RvvInt32mf2:
5020  case clang::BuiltinType::RvvInt32m1:
5021  case clang::BuiltinType::RvvInt32m2:
5022  case clang::BuiltinType::RvvInt32m4:
5023  case clang::BuiltinType::RvvInt32m8:
5024  case clang::BuiltinType::RvvUint32mf2:
5025  case clang::BuiltinType::RvvUint32m1:
5026  case clang::BuiltinType::RvvUint32m2:
5027  case clang::BuiltinType::RvvUint32m4:
5028  case clang::BuiltinType::RvvUint32m8:
5029  case clang::BuiltinType::RvvInt64m1:
5030  case clang::BuiltinType::RvvInt64m2:
5031  case clang::BuiltinType::RvvInt64m4:
5032  case clang::BuiltinType::RvvInt64m8:
5033  case clang::BuiltinType::RvvUint64m1:
5034  case clang::BuiltinType::RvvUint64m2:
5035  case clang::BuiltinType::RvvUint64m4:
5036  case clang::BuiltinType::RvvUint64m8:
5037  case clang::BuiltinType::RvvFloat16mf4:
5038  case clang::BuiltinType::RvvFloat16mf2:
5039  case clang::BuiltinType::RvvFloat16m1:
5040  case clang::BuiltinType::RvvFloat16m2:
5041  case clang::BuiltinType::RvvFloat16m4:
5042  case clang::BuiltinType::RvvFloat16m8:
5043  case clang::BuiltinType::RvvFloat32mf2:
5044  case clang::BuiltinType::RvvFloat32m1:
5045  case clang::BuiltinType::RvvFloat32m2:
5046  case clang::BuiltinType::RvvFloat32m4:
5047  case clang::BuiltinType::RvvFloat32m8:
5048  case clang::BuiltinType::RvvFloat64m1:
5049  case clang::BuiltinType::RvvFloat64m2:
5050  case clang::BuiltinType::RvvFloat64m4:
5051  case clang::BuiltinType::RvvFloat64m8:
5052  case clang::BuiltinType::RvvBool1:
5053  case clang::BuiltinType::RvvBool2:
5054  case clang::BuiltinType::RvvBool4:
5055  case clang::BuiltinType::RvvBool8:
5056  case clang::BuiltinType::RvvBool16:
5057  case clang::BuiltinType::RvvBool32:
5058  case clang::BuiltinType::RvvBool64:
5059  break;
5060 
5061  case clang::BuiltinType::IncompleteMatrixIdx:
5062  break;
5063  }
5064  break;
5065  // All pointer types are represented as unsigned integer encodings. We may
5066  // nee to add a eEncodingPointer if we ever need to know the difference
5067  case clang::Type::ObjCObjectPointer:
5068  case clang::Type::BlockPointer:
5069  case clang::Type::Pointer:
5070  case clang::Type::LValueReference:
5071  case clang::Type::RValueReference:
5072  case clang::Type::MemberPointer:
5073  return lldb::eEncodingUint;
5074  case clang::Type::Complex: {
5076  if (qual_type->isComplexType())
5077  encoding = lldb::eEncodingIEEE754;
5078  else {
5079  const clang::ComplexType *complex_type =
5080  qual_type->getAsComplexIntegerType();
5081  if (complex_type)
5082  encoding = GetType(complex_type->getElementType()).GetEncoding(count);
5083  else
5084  encoding = lldb::eEncodingSint;
5085  }
5086  count = 2;
5087  return encoding;
5088  }
5089 
5090  case clang::Type::ObjCInterface:
5091  break;
5092  case clang::Type::Record:
5093  break;
5094  case clang::Type::Enum:
5095  return lldb::eEncodingSint;
5096  case clang::Type::DependentSizedArray:
5097  case clang::Type::DependentSizedExtVector:
5098  case clang::Type::UnresolvedUsing:
5099  case clang::Type::Attributed:
5100  case clang::Type::TemplateTypeParm:
5101  case clang::Type::SubstTemplateTypeParm:
5102  case clang::Type::SubstTemplateTypeParmPack:
5103  case clang::Type::InjectedClassName:
5104  case clang::Type::DependentName:
5105  case clang::Type::DependentTemplateSpecialization:
5106  case clang::Type::PackExpansion:
5107  case clang::Type::ObjCObject:
5108 
5109  case clang::Type::TemplateSpecialization:
5110  case clang::Type::DeducedTemplateSpecialization:
5111  case clang::Type::Adjusted:
5112  case clang::Type::Pipe:
5113  break;
5114 
5115  // pointer type decayed from an array or function type.
5116  case clang::Type::Decayed:
5117  break;
5118  case clang::Type::ObjCTypeParam:
5119  break;
5120 
5121  case clang::Type::DependentAddressSpace:
5122  break;
5123  case clang::Type::MacroQualified:
5124  break;
5125 
5126  case clang::Type::ConstantMatrix:
5127  case clang::Type::DependentSizedMatrix:
5128  break;
5129  }
5130  count = 0;
5131  return lldb::eEncodingInvalid;
5132 }
5133 
5135  if (!type)
5136  return lldb::eFormatDefault;
5137 
5138  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5139 
5140  switch (qual_type->getTypeClass()) {
5141  case clang::Type::Atomic:
5142  case clang::Type::Auto:
5143  case clang::Type::Decltype:
5144  case clang::Type::Elaborated:
5145  case clang::Type::Paren:
5146  case clang::Type::Typedef:
5147  case clang::Type::TypeOf:
5148  case clang::Type::TypeOfExpr:
5149  case clang::Type::Using:
5150  llvm_unreachable("Handled in RemoveWrappingTypes!");
5151  case clang::Type::UnaryTransform:
5152  break;
5153 
5154  case clang::Type::FunctionNoProto:
5155  case clang::Type::FunctionProto:
5156  break;
5157 
5158  case clang::Type::IncompleteArray:
5159  case clang::Type::VariableArray:
5160  break;
5161 
5162  case clang::Type::ConstantArray:
5163  return lldb::eFormatVoid; // no value
5164 
5165  case clang::Type::DependentVector:
5166  case clang::Type::ExtVector:
5167  case clang::Type::Vector:
5168  break;
5169 
5170  case clang::Type::BitInt:
5171  case clang::Type::DependentBitInt:
5172  return qual_type->isUnsignedIntegerType() ? lldb::eFormatUnsigned
5174 
5175  case clang::Type::Builtin:
5176  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5177  case clang::BuiltinType::UnknownAny:
5178  case clang::BuiltinType::Void:
5179  case clang::BuiltinType::BoundMember:
5180  break;
5181 
5182  case clang::BuiltinType::Bool:
5183  return lldb::eFormatBoolean;
5184  case clang::BuiltinType::Char_S:
5185  case clang::BuiltinType::SChar:
5186  case clang::BuiltinType::WChar_S:
5187  case clang::BuiltinType::Char_U:
5188  case clang::BuiltinType::UChar:
5189  case clang::BuiltinType::WChar_U:
5190  return lldb::eFormatChar;
5191  case clang::BuiltinType::Char8:
5192  return lldb::eFormatUnicode8;
5193  case clang::BuiltinType::Char16:
5194  return lldb::eFormatUnicode16;
5195  case clang::BuiltinType::Char32:
5196  return lldb::eFormatUnicode32;
5197  case clang::BuiltinType::UShort:
5198  return lldb::eFormatUnsigned;
5199  case clang::BuiltinType::Short:
5200  return lldb::eFormatDecimal;
5202  return lldb::eFormatUnsigned;
5203  case clang::BuiltinType::Int:
5204  return lldb::eFormatDecimal;
5205  case clang::BuiltinType::ULong:
5206  return lldb::eFormatUnsigned;
5207  case clang::BuiltinType::Long:
5208  return lldb::eFormatDecimal;
5209  case clang::BuiltinType::ULongLong:
5210  return lldb::eFormatUnsigned;
5211  case clang::BuiltinType::LongLong:
5212  return lldb::eFormatDecimal;
5213  case clang::BuiltinType::UInt128:
5214  return lldb::eFormatUnsigned;
5215  case clang::BuiltinType::Int128:
5216  return lldb::eFormatDecimal;
5217  case clang::BuiltinType::Half:
5218  case clang::BuiltinType::Float:
5219  case clang::BuiltinType::Double:
5220  case clang::BuiltinType::LongDouble:
5221  return lldb::eFormatFloat;
5222  default:
5223  return lldb::eFormatHex;
5224  }
5225  break;
5226  case clang::Type::ObjCObjectPointer:
5227  return lldb::eFormatHex;
5228  case clang::Type::BlockPointer:
5229  return lldb::eFormatHex;
5230  case clang::Type::Pointer:
5231  return lldb::eFormatHex;
5232  case clang::Type::LValueReference:
5233  case clang::Type::RValueReference:
5234  return lldb::eFormatHex;
5235  case clang::Type::MemberPointer:
5236  break;
5237  case clang::Type::Complex: {
5238  if (qual_type->isComplexType())
5239  return lldb::eFormatComplex;
5240  else
5242  }
5243  case clang::Type::ObjCInterface:
5244  break;
5245  case clang::Type::Record:
5246  break;
5247  case clang::Type::Enum:
5248  return lldb::eFormatEnum;
5249  case clang::Type::DependentSizedArray:
5250  case clang::Type::DependentSizedExtVector:
5251  case clang::Type::UnresolvedUsing:
5252  case clang::Type::Attributed:
5253  case clang::Type::TemplateTypeParm:
5254  case clang::Type::SubstTemplateTypeParm:
5255  case clang::Type::SubstTemplateTypeParmPack:
5256  case clang::Type::InjectedClassName:
5257  case clang::Type::DependentName:
5258  case clang::Type::DependentTemplateSpecialization:
5259  case clang::Type::PackExpansion:
5260  case clang::Type::ObjCObject:
5261 
5262  case clang::Type::TemplateSpecialization:
5263  case clang::Type::DeducedTemplateSpecialization:
5264  case clang::Type::Adjusted:
5265  case clang::Type::Pipe:
5266  break;
5267 
5268  // pointer type decayed from an array or function type.
5269  case clang::Type::Decayed:
5270  break;
5271  case clang::Type::ObjCTypeParam:
5272  break;
5273 
5274  case clang::Type::DependentAddressSpace:
5275  break;
5276  case clang::Type::MacroQualified:
5277  break;
5278 
5279  // Matrix types we're not sure how to display yet.
5280  case clang::Type::ConstantMatrix:
5281  case clang::Type::DependentSizedMatrix:
5282  break;
5283  }
5284  // We don't know hot to display this type...
5285  return lldb::eFormatBytes;
5286 }
5287 
5288 static bool ObjCDeclHasIVars(clang::ObjCInterfaceDecl *class_interface_decl,
5289  bool check_superclass) {
5290  while (class_interface_decl) {
5291  if (class_interface_decl->ivar_size() > 0)
5292  return true;
5293 
5294  if (check_superclass)
5295  class_interface_decl = class_interface_decl->getSuperClass();
5296  else
5297  break;
5298  }
5299  return false;
5300 }
5301 
5302 static Optional<SymbolFile::ArrayInfo>
5304  clang::QualType qual_type,
5305  const ExecutionContext *exe_ctx) {
5306  if (qual_type->isIncompleteArrayType())
5307  if (auto *metadata = ast.GetMetadata(qual_type.getTypePtr()))
5308  return sym_file->GetDynamicArrayInfoForUID(metadata->GetUserID(),
5309  exe_ctx);
5310  return llvm::None;
5311 }
5312 
5314  bool omit_empty_base_classes,
5315  const ExecutionContext *exe_ctx) {
5316  if (!type)
5317  return 0;
5318 
5319  uint32_t num_children = 0;
5320  clang::QualType qual_type(RemoveWrappingTypes(GetQualType(type)));
5321  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5322  switch (type_class) {
5323  case clang::Type::Builtin:
5324  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5325  case clang::BuiltinType::ObjCId: // child is Class
5326  case clang::BuiltinType::ObjCClass: // child is Class
5327  num_children = 1;
5328  break;
5329 
5330  default:
5331  break;
5332  }
5333  break;
5334 
5335  case clang::Type::Complex:
5336  return 0;
5337  case clang::Type::Record:
5338  if (GetCompleteQualType(&getASTContext(), qual_type)) {
5339  const clang::RecordType *record_type =
5340  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5341  const clang::RecordDecl *record_decl = record_type->getDecl();
5342  assert(record_decl);
5343  const clang::CXXRecordDecl *cxx_record_decl =
5344  llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5345  if (cxx_record_decl) {
5346  if (omit_empty_base_classes) {
5347  // Check each base classes to see if it or any of its base classes
5348  // contain any fields. This can help limit the noise in variable
5349  // views by not having to show base classes that contain no members.
5350  clang::CXXRecordDecl::base_class_const_iterator base_class,
5351  base_class_end;
5352  for (base_class = cxx_record_decl->bases_begin(),
5353  base_class_end = cxx_record_decl->bases_end();
5354  base_class != base_class_end; ++base_class) {
5355  const clang::CXXRecordDecl *base_class_decl =
5356  llvm::cast<clang::CXXRecordDecl>(
5357  base_class->getType()
5358  ->getAs<clang::RecordType>()
5359  ->getDecl());
5360 
5361  // Skip empty base classes
5362  if (!TypeSystemClang::RecordHasFields(base_class_decl))
5363  continue;
5364 
5365  num_children++;
5366  }
5367  } else {
5368  // Include all base classes
5369  num_children += cxx_record_decl->getNumBases();
5370  }
5371  }
5372  clang::RecordDecl::field_iterator field, field_end;
5373  for (field = record_decl->field_begin(),
5374  field_end = record_decl->field_end();
5375  field != field_end; ++field)
5376  ++num_children;
5377  }
5378  break;
5379 
5380  case clang::Type::ObjCObject:
5381  case clang::Type::ObjCInterface:
5382  if (GetCompleteQualType(&getASTContext(), qual_type)) {
5383  const clang::ObjCObjectType *objc_class_type =
5384  llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5385  assert(objc_class_type);
5386  if (objc_class_type) {
5387  clang::ObjCInterfaceDecl *class_interface_decl =
5388  objc_class_type->getInterface();
5389 
5390  if (class_interface_decl) {
5391 
5392  clang::ObjCInterfaceDecl *superclass_interface_decl =
5393  class_interface_decl->getSuperClass();
5394  if (superclass_interface_decl) {
5395  if (omit_empty_base_classes) {
5396  if (ObjCDeclHasIVars(superclass_interface_decl, true))
5397  ++num_children;
5398  } else
5399  ++num_children;
5400  }
5401 
5402  num_children += class_interface_decl->ivar_size();
5403  }
5404  }
5405  }
5406  break;
5407 
5408  case clang::Type::LValueReference:
5409  case clang::Type::RValueReference:
5410  case clang::Type::ObjCObjectPointer: {
5411  CompilerType pointee_clang_type(GetPointeeType(type));
5412 
5413  uint32_t num_pointee_children = 0;
5414  if (pointee_clang_type.IsAggregateType())
5415  num_pointee_children =
5416  pointee_clang_type.GetNumChildren(omit_empty_base_classes, exe_ctx);
5417  // If this type points to a simple type, then it has 1 child
5418  if (num_pointee_children == 0)
5419  num_children = 1;
5420  else
5421  num_children = num_pointee_children;
5422  } break;
5423 
5424  case clang::Type::Vector:
5425  case clang::Type::ExtVector:
5426  num_children =
5427  llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
5428  break;
5429 
5430  case clang::Type::ConstantArray:
5431  num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())
5432  ->getSize()
5433  .getLimitedValue();
5434  break;
5435  case clang::Type::IncompleteArray:
5436  if (auto array_info =
5437  GetDynamicArrayInfo(*this, GetSymbolFile(), qual_type, exe_ctx))
5438  // Only 1-dimensional arrays are supported.
5439  num_children = array_info->element_orders.size()
5440  ? array_info->element_orders.back()
5441  : 0;
5442  break;
5443 
5444  case clang::Type::Pointer: {
5445  const clang::PointerType *pointer_type =
5446  llvm::cast<clang::PointerType>(qual_type.getTypePtr());
5447  clang::QualType pointee_type(pointer_type->getPointeeType());
5448  CompilerType pointee_clang_type(GetType(pointee_type));
5449  uint32_t num_pointee_children = 0;
5450  if (pointee_clang_type.IsAggregateType())
5451  num_pointee_children =
5452  pointee_clang_type.GetNumChildren(omit_empty_base_classes, exe_ctx);
5453  if (num_pointee_children == 0) {
5454  // We have a pointer to a pointee type that claims it has no children. We
5455  // will want to look at
5456  num_children = GetNumPointeeChildren(pointee_type);
5457  } else
5458  num_children = num_pointee_children;
5459  } break;
5460 
5461  default:
5462  break;
5463  }
5464  return num_children;
5465 }
5466 
5468  return GetBasicType(GetBasicTypeEnumeration(name));
5469 }
5470 
5473  if (type) {
5474  clang::QualType qual_type(GetQualType(type));
5475  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5476  if (type_class == clang::Type::Builtin) {
5477  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5478  case clang::BuiltinType::Void:
5479  return eBasicTypeVoid;
5480  case clang::BuiltinType::Bool:
5481  return eBasicTypeBool;
5482  case clang::BuiltinType::Char_S:
5483  return eBasicTypeSignedChar;
5484  case clang::BuiltinType::Char_U:
5485  return eBasicTypeUnsignedChar;
5486  case clang::BuiltinType::Char16:
5487  return eBasicTypeChar16;
5488  case clang::BuiltinType::Char32:
5489  return eBasicTypeChar32;
5490  case clang::BuiltinType::UChar:
5491  return eBasicTypeUnsignedChar;
5492  case clang::BuiltinType::SChar:
5493  return eBasicTypeSignedChar;
5494  case clang::BuiltinType::WChar_S:
5495  return eBasicTypeSignedWChar;
5496  case clang::BuiltinType::WChar_U:
5497  return eBasicTypeUnsignedWChar;
5498  case clang::BuiltinType::Short:
5499  return eBasicTypeShort;
5500  case clang::BuiltinType::UShort:
5501  return eBasicTypeUnsignedShort;
5502  case clang::BuiltinType::Int:
5503  return eBasicTypeInt;
5505  return eBasicTypeUnsignedInt;
5506  case clang::BuiltinType::Long:
5507  return eBasicTypeLong;
5508  case clang::BuiltinType::ULong:
5509  return eBasicTypeUnsignedLong;
5510  case clang::BuiltinType::LongLong:
5511  return eBasicTypeLongLong;
5512  case clang::BuiltinType::ULongLong:
5514  case clang::BuiltinType::Int128:
5515  return eBasicTypeInt128;
5516  case clang::BuiltinType::UInt128:
5517  return eBasicTypeUnsignedInt128;
5518 
5519  case clang::BuiltinType::Half:
5520  return eBasicTypeHalf;
5521  case clang::BuiltinType::Float:
5522  return eBasicTypeFloat;
5523  case clang::BuiltinType::Double:
5524  return eBasicTypeDouble;
5525  case clang::BuiltinType::LongDouble:
5526  return eBasicTypeLongDouble;
5527 
5528  case clang::BuiltinType::NullPtr:
5529  return eBasicTypeNullPtr;
5530  case clang::BuiltinType::ObjCId:
5531  return eBasicTypeObjCID;
5532  case clang::BuiltinType::ObjCClass:
5533  return eBasicTypeObjCClass;
5534  case clang::BuiltinType::ObjCSel:
5535  return eBasicTypeObjCSel;
5536  default:
5537  return eBasicTypeOther;
5538  }
5539  }
5540  }
5541  return eBasicTypeInvalid;
5542 }
5543 
5546  std::function<bool(const CompilerType &integer_type,
5547  ConstString name,
5548  const llvm::APSInt &value)> const &callback) {
5549  const clang::EnumType *enum_type =
5550  llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
5551  if (enum_type) {
5552  const clang::EnumDecl *enum_decl = enum_type->getDecl();
5553  if (enum_decl) {
5554  CompilerType integer_type = GetType(enum_decl->getIntegerType());
5555 
5556  clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5557  for (enum_pos = enum_decl->enumerator_begin(),
5558  enum_end_pos = enum_decl->enumerator_end();
5559  enum_pos != enum_end_pos; ++enum_pos) {
5560  ConstString name(enum_pos->getNameAsString().c_str());
5561  if (!callback(integer_type, name, enum_pos->getInitVal()))
5562  break;
5563  }
5564  }
5565  }
5566 }
5567 
5568 #pragma mark Aggregate Types
5569 
5571  if (!type)
5572  return 0;
5573 
5574  uint32_t count = 0;
5575  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
5576  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5577  switch (type_class) {
5578  case clang::Type::Record:
5579  if (GetCompleteType(type)) {
5580  const clang::RecordType *record_type =
5581  llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
5582  if (record_type) {
5583  clang::RecordDecl *record_decl = record_type->getDecl();
5584  if (record_decl) {
5585  uint32_t field_idx = 0;
5586  clang::RecordDecl::field_iterator field, field_end;
5587  for (field = record_decl->field_begin(),
5588  field_end = record_decl->field_end();
5589  field != field_end; ++field)
5590  ++field_idx;
5591  count = field_idx;
5592  }
5593  }
5594  }
5595  break;
5596 
5597  case clang::Type::ObjCObjectPointer: {
5598  const clang::ObjCObjectPointerType *objc_class_type =
5599  qual_type->getAs<clang::ObjCObjectPointerType>();
5600  const clang::ObjCInterfaceType *objc_interface_type =
5601  objc_class_type->getInterfaceType();
5602  if (objc_interface_type &&
5604  const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
5605  clang::ObjCInterfaceDecl *class_interface_decl =
5606  objc_interface_type->getDecl();
5607  if (class_interface_decl) {
5608  count = class_interface_decl->ivar_size();
5609  }
5610  }
5611  break;
5612  }
5613 
5614  case clang::Type::ObjCObject:
5615  case clang::Type::ObjCInterface:
5616  if (GetCompleteType(type)) {
5617  const clang::ObjCObjectType *objc_class_type =
5618  llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5619  if (objc_class_type) {
5620  clang::ObjCInterfaceDecl *class_interface_decl =
5621  objc_class_type->getInterface();
5622 
5623  if (class_interface_decl)
5624  count = class_interface_decl->ivar_size();
5625  }
5626  }
5627  break;
5628 
5629  default:
5630  break;
5631  }
5632  return count;
5633 }
5634 
5636 GetObjCFieldAtIndex(clang::ASTContext *ast,
5637  clang::ObjCInterfaceDecl *class_interface_decl, size_t idx,
5638  std::string &name, uint64_t *bit_offset_ptr,
5639  uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) {
5640  if (class_interface_decl) {
5641  if (idx < (class_interface_decl->ivar_size())) {
5642  clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
5643  ivar_end = class_interface_decl->ivar_end();
5644  uint32_t ivar_idx = 0;
5645 
5646  for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end;
5647  ++ivar_pos, ++ivar_idx) {
5648  if (ivar_idx == idx) {
5649  const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
5650 
5651  clang::QualType ivar_qual_type(ivar_decl->getType());
5652 
5653  name.assign(ivar_decl->getNameAsString());
5654 
5655  if (bit_offset_ptr) {
5656  const clang::ASTRecordLayout &interface_layout =
5657  ast->getASTObjCInterfaceLayout(class_interface_decl);
5658  *bit_offset_ptr = interface_layout.getFieldOffset(ivar_idx);
5659  }
5660 
5661  const bool is_bitfield = ivar_pos->isBitField();
5662 
5663  if (bitfield_bit_size_ptr) {
5664  *bitfield_bit_size_ptr = 0;
5665 
5666  if (is_bitfield && ast) {
5667  clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5668  clang::Expr::EvalResult result;
5669  if (bitfield_bit_size_expr &&
5670  bitfield_bit_size_expr->EvaluateAsInt(result, *ast)) {
5671  llvm::APSInt bitfield_apsint = result.Val.getInt();
5672  *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5673  }
5674  }
5675  }
5676  if (is_bitfield_ptr)
5677  *is_bitfield_ptr = is_bitfield;
5678 
5679  return ivar_qual_type.getAsOpaquePtr();
5680  }
5681  }
5682  }
5683  }
5684  return nullptr;
5685 }
5686 
5688  size_t idx, std::string &name,
5689  uint64_t *bit_offset_ptr,
5690  uint32_t *bitfield_bit_size_ptr,
5691  bool *is_bitfield_ptr) {
5692  if (!type)
5693  return CompilerType();
5694 
5695  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
5696  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5697  switch (type_class) {
5698  case clang::Type::Record:
5699  if (GetCompleteType(type)) {
5700  const clang::RecordType *record_type =
5701  llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5702  const clang::RecordDecl *record_decl = record_type->getDecl();
5703  uint32_t field_idx = 0;
5704  clang::RecordDecl::field_iterator field, field_end;
5705  for (field = record_decl->field_begin(),
5706  field_end = record_decl->field_end();
5707  field != field_end; ++field, ++field_idx) {
5708  if (idx == field_idx) {
5709  // Print the member type if requested
5710  // Print the member name and equal sign
5711  name.assign(field->getNameAsString());
5712 
5713  // Figure out the type byte size (field_type_info.first) and
5714  // alignment (field_type_info.second) from the AST context.
5715  if (bit_offset_ptr) {
5716  const clang::ASTRecordLayout &record_layout =
5717  getASTContext().getASTRecordLayout(record_decl);
5718  *bit_offset_ptr = record_layout.getFieldOffset(field_idx);
5719  }
5720 
5721  const bool is_bitfield = field->isBitField();
5722 
5723  if (bitfield_bit_size_ptr) {
5724  *bitfield_bit_size_ptr = 0;
5725 
5726  if (is_bitfield) {
5727  clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
5728  clang::Expr::EvalResult result;
5729  if (bitfield_bit_size_expr &&
5730  bitfield_bit_size_expr->EvaluateAsInt(result,
5731  getASTContext())) {
5732  llvm::APSInt bitfield_apsint = result.Val.getInt();
5733  *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5734  }
5735  }
5736  }
5737  if (is_bitfield_ptr)
5738  *is_bitfield_ptr = is_bitfield;
5739 
5740  return GetType(field->getType());
5741  }
5742  }
5743  }
5744  break;
5745 
5746  case clang::Type::ObjCObjectPointer: {
5747  const clang::ObjCObjectPointerType *objc_class_type =
5748  qual_type->getAs<clang::ObjCObjectPointerType>();
5749  const clang::ObjCInterfaceType *objc_interface_type =
5750  objc_class_type->getInterfaceType();
5751  if (objc_interface_type &&
5753  const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
5754  clang::ObjCInterfaceDecl *class_interface_decl =
5755  objc_interface_type->getDecl();
5756  if (class_interface_decl) {
5757  return CompilerType(
5758  this, GetObjCFieldAtIndex(&getASTContext(), class_interface_decl,
5759  idx, name, bit_offset_ptr,
5760  bitfield_bit_size_ptr, is_bitfield_ptr));
5761  }
5762  }
5763  break;
5764  }
5765 
5766  case clang::Type::ObjCObject:
5767  case clang::Type::ObjCInterface:
5768  if (GetCompleteType(type)) {
5769  const clang::ObjCObjectType *objc_class_type =
5770  llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5771  assert(objc_class_type);
5772  if (objc_class_type) {
5773  clang::ObjCInterfaceDecl *class_interface_decl =
5774  objc_class_type->getInterface();
5775  return CompilerType(
5776  this, GetObjCFieldAtIndex(&getASTContext(), class_interface_decl,
5777  idx, name, bit_offset_ptr,
5778  bitfield_bit_size_ptr, is_bitfield_ptr));
5779  }
5780  }
5781  break;
5782 
5783  default:
5784  break;
5785  }
5786  return CompilerType();
5787 }
5788 
5789 uint32_t
5791  uint32_t count = 0;
5792  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5793  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5794  switch (type_class) {
5795  case clang::Type::Record:
5796  if (GetCompleteType(type)) {
5797  const clang::CXXRecordDecl *cxx_record_decl =
5798  qual_type->getAsCXXRecordDecl();
5799  if (cxx_record_decl)
5800  count = cxx_record_decl->getNumBases();
5801  }
5802  break;
5803 
5804  case clang::Type::ObjCObjectPointer:
5805  count = GetPointeeType(type).GetNumDirectBaseClasses();
5806  break;
5807 
5808  case clang::Type::ObjCObject:
5809  if (GetCompleteType(type)) {
5810  const clang::ObjCObjectType *objc_class_type =
5811  qual_type->getAsObjCQualifiedInterfaceType();
5812  if (objc_class_type) {
5813  clang::ObjCInterfaceDecl *class_interface_decl =
5814  objc_class_type->getInterface();
5815 
5816  if (class_interface_decl && class_interface_decl->getSuperClass())
5817  count = 1;
5818  }
5819  }
5820  break;
5821  case clang::Type::ObjCInterface:
5822  if (GetCompleteType(type)) {
5823  const clang::ObjCInterfaceType *objc_interface_type =
5824  qual_type->getAs<clang::ObjCInterfaceType>();
5825  if (objc_interface_type) {
5826  clang::ObjCInterfaceDecl *class_interface_decl =
5827  objc_interface_type->getInterface();
5828 
5829  if (class_interface_decl && class_interface_decl->getSuperClass())
5830  count = 1;
5831  }
5832  }
5833  break;
5834 
5835  default:
5836  break;
5837  }
5838  return count;
5839 }
5840 
5841 uint32_t
5843  uint32_t count = 0;
5844  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5845  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5846  switch (type_class) {
5847  case clang::Type::Record:
5848  if (GetCompleteType(type)) {
5849  const clang::CXXRecordDecl *cxx_record_decl =
5850  qual_type->getAsCXXRecordDecl();
5851  if (cxx_record_decl)
5852  count = cxx_record_decl->getNumVBases();
5853  }
5854  break;
5855 
5856  default:
5857  break;
5858  }
5859  return count;
5860 }
5861 
5863  lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
5864  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5865  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5866  switch (type_class) {
5867  case clang::Type::Record:
5868  if (GetCompleteType(type)) {
5869  const clang::CXXRecordDecl *cxx_record_decl =
5870  qual_type->getAsCXXRecordDecl();
5871  if (cxx_record_decl) {
5872  uint32_t curr_idx = 0;
5873  clang::CXXRecordDecl::base_class_const_iterator base_class,
5874  base_class_end;
5875  for (base_class = cxx_record_decl->bases_begin(),
5876  base_class_end = cxx_record_decl->bases_end();
5877  base_class != base_class_end; ++base_class, ++curr_idx) {
5878  if (curr_idx == idx) {
5879  if (bit_offset_ptr) {
5880  const clang::ASTRecordLayout &record_layout =
5881  getASTContext().getASTRecordLayout(cxx_record_decl);
5882  const clang::CXXRecordDecl *base_class_decl =
5883  llvm::cast<clang::CXXRecordDecl>(
5884  base_class->getType()
5885  ->getAs<clang::RecordType>()
5886  ->getDecl());
5887  if (base_class->isVirtual())
5888  *bit_offset_ptr =
5889  record_layout.getVBaseClassOffset(base_class_decl)
5890  .getQuantity() *
5891  8;
5892  else
5893  *bit_offset_ptr =
5894  record_layout.getBaseClassOffset(base_class_decl)
5895  .getQuantity() *
5896  8;
5897  }
5898  return GetType(base_class->getType());
5899  }
5900  }
5901  }
5902  }
5903  break;
5904 
5905  case clang::Type::ObjCObjectPointer:
5906  return GetPointeeType(type).GetDirectBaseClassAtIndex(idx, bit_offset_ptr);
5907 
5908  case clang::Type::ObjCObject:
5909  if (idx == 0 && GetCompleteType(type)) {
5910  const clang::ObjCObjectType *objc_class_type =
5911  qual_type->getAsObjCQualifiedInterfaceType();
5912  if (objc_class_type) {
5913  clang::ObjCInterfaceDecl *class_interface_decl =
5914  objc_class_type->getInterface();
5915 
5916  if (class_interface_decl) {
5917  clang::ObjCInterfaceDecl *superclass_interface_decl =
5918  class_interface_decl->getSuperClass();
5919  if (superclass_interface_decl) {
5920  if (bit_offset_ptr)
5921  *bit_offset_ptr = 0;
5922  return GetType(getASTContext().getObjCInterfaceType(
5923  superclass_interface_decl));
5924  }
5925  }
5926  }
5927  }
5928  break;
5929  case clang::Type::ObjCInterface:
5930  if (idx == 0 && GetCompleteType(type)) {
5931  const clang::ObjCObjectType *objc_interface_type =
5932  qual_type->getAs<clang::ObjCInterfaceType>();
5933  if (objc_interface_type) {
5934  clang::ObjCInterfaceDecl *class_interface_decl =
5935  objc_interface_type->getInterface();
5936 
5937  if (class_interface_decl) {
5938  clang::ObjCInterfaceDecl *superclass_interface_decl =
5939  class_interface_decl->getSuperClass();
5940  if (superclass_interface_decl) {
5941  if (bit_offset_ptr)
5942  *bit_offset_ptr = 0;
5943  return GetType(getASTContext().getObjCInterfaceType(
5944  superclass_interface_decl));
5945  }
5946  }
5947  }
5948  }
5949  break;
5950 
5951  default:
5952  break;
5953  }
5954  return CompilerType();
5955 }
5956 
5958  lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
5959  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
5960  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5961  switch (type_class) {
5962  case clang::Type::Record:
5963  if (GetCompleteType(type)) {
5964  const clang::CXXRecordDecl *cxx_record_decl =
5965  qual_type->getAsCXXRecordDecl();
5966  if (cxx_record_decl) {
5967  uint32_t curr_idx = 0;
5968  clang::CXXRecordDecl::base_class_const_iterator base_class,
5969  base_class_end;
5970  for (base_class = cxx_record_decl->vbases_begin(),
5971  base_class_end = cxx_record_decl->vbases_end();
5972  base_class != base_class_end; ++base_class, ++curr_idx) {
5973  if (curr_idx == idx) {
5974  if (bit_offset_ptr) {
5975  const clang::ASTRecordLayout &record_layout =
5976  getASTContext().getASTRecordLayout(cxx_record_decl);
5977  const clang::CXXRecordDecl *base_class_decl =
5978  llvm::cast<clang::CXXRecordDecl>(
5979  base_class->getType()
5980  ->getAs<clang::RecordType>()
5981  ->getDecl());
5982  *bit_offset_ptr =
5983  record_layout.getVBaseClassOffset(base_class_decl)
5984  .getQuantity() *
5985  8;
5986  }
5987  return GetType(base_class->getType());
5988  }
5989  }
5990  }
5991  }
5992  break;
5993 
5994  default:
5995  break;
5996  }
5997  return CompilerType();
5998 }
5999 
6000 // If a pointer to a pointee type (the clang_type arg) says that it has no
6001 // children, then we either need to trust it, or override it and return a
6002 // different result. For example, an "int *" has one child that is an integer,
6003 // but a function pointer doesn't have any children. Likewise if a Record type
6004 // claims it has no children, then there really is nothing to show.
6006  if (type.isNull())
6007  return 0;
6008 
6009  clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
6010  const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6011  switch (type_class) {
6012  case clang::Type::Builtin:
6013  switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
6014  case clang::BuiltinType::UnknownAny:
6015  case clang::BuiltinType::Void:
6016  case clang::BuiltinType::NullPtr:
6017  case clang::BuiltinType::OCLEvent:
6018  case clang::BuiltinType::OCLImage1dRO:
6019  case clang::BuiltinType::OCLImage1dWO:
6020  case clang::BuiltinType::OCLImage1dRW:
6021  case clang::BuiltinType::OCLImage1dArrayRO:
6022  case clang::BuiltinType::OCLImage1dArrayWO:
6023  case clang::BuiltinType::OCLImage1dArrayRW:
6024  case clang::BuiltinType::OCLImage1dBufferRO:
6025  case clang::BuiltinType::OCLImage1dBufferWO:
6026  case clang::BuiltinType::OCLImage1dBufferRW:
6027  case clang::BuiltinType::OCLImage2dRO:
6028  case clang::BuiltinType::OCLImage2dWO:
6029  case clang::BuiltinType::OCLImage2dRW:
6030  case clang::BuiltinType::OCLImage2dArrayRO:
6031  case clang::BuiltinType::OCLImage2dArrayWO:
6032  case clang::BuiltinType::OCLImage2dArrayRW:
6033  case clang::BuiltinType::OCLImage3dRO:
6034  case clang::BuiltinType::OCLImage3dWO:
6035  case clang::BuiltinType::OCLImage3dRW:
6036  case clang::BuiltinType::OCLSampler:
6037  return 0;
6038  case clang::BuiltinType::Bool:
6039  case clang::BuiltinType::Char_U:
6040  case clang::BuiltinType::UChar:
6041  case clang::BuiltinType::WChar_U:
6042  case clang::BuiltinType::Char16:
6043  case clang::BuiltinType::Char32:
6044  case clang::BuiltinType::UShort:
6046  case clang::BuiltinType::ULong:
6047  case clang::BuiltinType::ULongLong:
6048  case clang::BuiltinType::UInt128:
6049  case clang::BuiltinType::Char_S:
6050  case clang::BuiltinType::SChar:
6051  case clang::BuiltinType::WChar_S:
6052  case clang::BuiltinType::Short:
6053  case clang::BuiltinType::Int:
6054  case clang::BuiltinType::Long:
6055  case clang::BuiltinType::LongLong:
6056  case clang::BuiltinType::Int128:
6057  case clang::BuiltinType::Float:
6058  case clang::BuiltinType::Double:
6059  case clang::BuiltinType::LongDouble:
6060  case clang::BuiltinType::Dependent:
6061  case clang::BuiltinType::Overload:
6062  case clang::BuiltinType::ObjCId:
6063  case clang::BuiltinType::ObjCClass:
6064  case clang::BuiltinType::ObjCSel:
6065  case clang::BuiltinType::BoundMember:
6066  case clang::BuiltinType::Half:
6067  case clang::BuiltinType::ARCUnbridgedCast:
6068  case clang::BuiltinType::PseudoObject:
6069  case clang::BuiltinType::BuiltinFn:
6070  case clang::BuiltinType::OMPArraySection:
6071  return 1;
6072  default:
6073  return 0;
6074  }
6075  break;
6076 
6077  case clang::Type::Complex:
6078  return 1;
6079  case clang::Type::Pointer:
6080  return 1;
6081  case clang::Type::BlockPointer:
6082  return 0; // If block pointers don't have debug info, then no children for
6083  // them
6084  case clang::Type::LValueReference:
6085  return 1;
6086  case clang::Type::RValueReference:
6087  return 1;
6088  case clang::Type::MemberPointer:
6089  return 0;
6090  case clang::Type::ConstantArray:
6091  return 0;
6092  case clang::Type::IncompleteArray:
6093  return 0;
6094  case clang::Type::VariableArray:
6095  return 0;
6096  case clang::Type::DependentSizedArray:
6097  return 0;
6098  case clang::Type::DependentSizedExtVector:
6099  return 0;
6100  case clang::Type::Vector:
6101  return 0;
6102  case clang::Type::ExtVector:
6103  return 0;
6104  case clang::Type::FunctionProto:
6105  return 0; // When we function pointers, they have no children...
6106  case clang::Type::FunctionNoProto:
6107  return 0; // When we function pointers, they have no children...
6108  case clang::Type::UnresolvedUsing:
6109  return 0;
6110  case clang::Type::Record:
6111  return 0;
6112  case clang::Type::Enum:
6113  return 1;
6114  case clang::Type::TemplateTypeParm:
6115  return 1;
6116  case clang::Type::SubstTemplateTypeParm:
6117  return 1;
6118  case clang::Type::TemplateSpecialization:
6119  return 1;
6120  case clang::Type::InjectedClassName:
6121  return 0;
6122  case clang::Type::DependentName:
6123  return 1;
6124  case clang::Type::DependentTemplateSpecialization:
6125  return 1;
6126  case clang::Type::ObjCObject:
6127  return 0;
6128  case clang::Type::ObjCInterface:
6129  return 0;
6130  case clang::Type::ObjCObjectPointer:
6131  return 1;
6132  default:
6133  break;
6134  }
6135  return 0;
6136 }
6137