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