1 //===-- Type.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 <cstdio> 10 11 #include "lldb/Core/Module.h" 12 #include "lldb/Utility/DataBufferHeap.h" 13 #include "lldb/Utility/DataExtractor.h" 14 #include "lldb/Utility/Log.h" 15 #include "lldb/Utility/Scalar.h" 16 #include "lldb/Utility/StreamString.h" 17 18 #include "lldb/Symbol/CompilerType.h" 19 #include "lldb/Symbol/ObjectFile.h" 20 #include "lldb/Symbol/SymbolContextScope.h" 21 #include "lldb/Symbol/SymbolFile.h" 22 #include "lldb/Symbol/SymbolVendor.h" 23 #include "lldb/Symbol/Type.h" 24 #include "lldb/Symbol/TypeList.h" 25 #include "lldb/Symbol/TypeSystem.h" 26 27 #include "lldb/Target/ExecutionContext.h" 28 #include "lldb/Target/Process.h" 29 #include "lldb/Target/Target.h" 30 31 #include "llvm/ADT/StringRef.h" 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 bool lldb_private::contextMatches(llvm::ArrayRef<CompilerContext> context_chain, 37 llvm::ArrayRef<CompilerContext> pattern) { 38 auto ctx = context_chain.begin(); 39 auto ctx_end = context_chain.end(); 40 for (const CompilerContext &pat : pattern) { 41 // Early exit if the pattern is too long. 42 if (ctx == ctx_end) 43 return false; 44 if (*ctx != pat) { 45 // Skip any number of module matches. 46 if (pat.kind == CompilerContextKind::AnyModule) { 47 // Greedily match 0..n modules. 48 ctx = std::find_if(ctx, ctx_end, [](const CompilerContext &ctx) { 49 return ctx.kind != CompilerContextKind::Module; 50 }); 51 continue; 52 } 53 // See if there is a kind mismatch; they should have 1 bit in common. 54 if (((uint16_t)ctx->kind & (uint16_t)pat.kind) == 0) 55 return false; 56 // The name is ignored for AnyModule, but not for AnyType. 57 if (pat.kind != CompilerContextKind::AnyModule && ctx->name != pat.name) 58 return false; 59 } 60 ++ctx; 61 } 62 return true; 63 } 64 65 void CompilerContext::Dump() const { 66 switch (kind) { 67 default: 68 printf("Invalid"); 69 break; 70 case CompilerContextKind::TranslationUnit: 71 printf("TranslationUnit"); 72 break; 73 case CompilerContextKind::Module: 74 printf("Module"); 75 break; 76 case CompilerContextKind::Namespace: 77 printf("Namespace"); 78 break; 79 case CompilerContextKind::Class: 80 printf("Class"); 81 break; 82 case CompilerContextKind::Struct: 83 printf("Structure"); 84 break; 85 case CompilerContextKind::Union: 86 printf("Union"); 87 break; 88 case CompilerContextKind::Function: 89 printf("Function"); 90 break; 91 case CompilerContextKind::Variable: 92 printf("Variable"); 93 break; 94 case CompilerContextKind::Enum: 95 printf("Enumeration"); 96 break; 97 case CompilerContextKind::Typedef: 98 printf("Typedef"); 99 break; 100 case CompilerContextKind::AnyModule: 101 printf("AnyModule"); 102 break; 103 case CompilerContextKind::AnyType: 104 printf("AnyType"); 105 break; 106 } 107 printf("(\"%s\")\n", name.GetCString()); 108 } 109 110 class TypeAppendVisitor { 111 public: 112 TypeAppendVisitor(TypeListImpl &type_list) : m_type_list(type_list) {} 113 114 bool operator()(const lldb::TypeSP &type) { 115 m_type_list.Append(TypeImplSP(new TypeImpl(type))); 116 return true; 117 } 118 119 private: 120 TypeListImpl &m_type_list; 121 }; 122 123 void TypeListImpl::Append(const lldb_private::TypeList &type_list) { 124 TypeAppendVisitor cb(*this); 125 type_list.ForEach(cb); 126 } 127 128 SymbolFileType::SymbolFileType(SymbolFile &symbol_file, 129 const lldb::TypeSP &type_sp) 130 : UserID(type_sp ? type_sp->GetID() : LLDB_INVALID_UID), 131 m_symbol_file(symbol_file), m_type_sp(type_sp) {} 132 133 Type *SymbolFileType::GetType() { 134 if (!m_type_sp) { 135 Type *resolved_type = m_symbol_file.ResolveTypeUID(GetID()); 136 if (resolved_type) 137 m_type_sp = resolved_type->shared_from_this(); 138 } 139 return m_type_sp.get(); 140 } 141 142 Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name, 143 llvm::Optional<uint64_t> byte_size, SymbolContextScope *context, 144 user_id_t encoding_uid, EncodingDataType encoding_uid_type, 145 const Declaration &decl, const CompilerType &compiler_type, 146 ResolveState compiler_type_resolve_state, uint32_t opaque_payload) 147 : std::enable_shared_from_this<Type>(), UserID(uid), m_name(name), 148 m_symbol_file(symbol_file), m_context(context), m_encoding_type(nullptr), 149 m_encoding_uid(encoding_uid), m_encoding_uid_type(encoding_uid_type), 150 m_decl(decl), m_compiler_type(compiler_type), 151 m_compiler_type_resolve_state(compiler_type ? compiler_type_resolve_state 152 : ResolveState::Unresolved), 153 m_payload(opaque_payload) { 154 if (byte_size) { 155 m_byte_size = *byte_size; 156 m_byte_size_has_value = true; 157 } else { 158 m_byte_size = 0; 159 m_byte_size_has_value = false; 160 } 161 } 162 163 Type::Type() 164 : std::enable_shared_from_this<Type>(), UserID(0), 165 m_name("<INVALID TYPE>") { 166 m_byte_size = 0; 167 m_byte_size_has_value = false; 168 } 169 170 void Type::GetDescription(Stream *s, lldb::DescriptionLevel level, 171 bool show_name, ExecutionContextScope *exe_scope) { 172 *s << "id = " << (const UserID &)*this; 173 174 // Call the name accessor to make sure we resolve the type name 175 if (show_name) { 176 ConstString type_name = GetName(); 177 if (type_name) { 178 *s << ", name = \"" << type_name << '"'; 179 ConstString qualified_type_name(GetQualifiedName()); 180 if (qualified_type_name != type_name) { 181 *s << ", qualified = \"" << qualified_type_name << '"'; 182 } 183 } 184 } 185 186 // Call the get byte size accesor so we resolve our byte size 187 if (GetByteSize(exe_scope)) 188 s->Printf(", byte-size = %" PRIu64, m_byte_size); 189 bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose); 190 m_decl.Dump(s, show_fullpaths); 191 192 if (m_compiler_type.IsValid()) { 193 *s << ", compiler_type = \""; 194 GetForwardCompilerType().DumpTypeDescription(s); 195 *s << '"'; 196 } else if (m_encoding_uid != LLDB_INVALID_UID) { 197 s->Printf(", type_uid = 0x%8.8" PRIx64, m_encoding_uid); 198 switch (m_encoding_uid_type) { 199 case eEncodingInvalid: 200 break; 201 case eEncodingIsUID: 202 s->PutCString(" (unresolved type)"); 203 break; 204 case eEncodingIsConstUID: 205 s->PutCString(" (unresolved const type)"); 206 break; 207 case eEncodingIsRestrictUID: 208 s->PutCString(" (unresolved restrict type)"); 209 break; 210 case eEncodingIsVolatileUID: 211 s->PutCString(" (unresolved volatile type)"); 212 break; 213 case eEncodingIsAtomicUID: 214 s->PutCString(" (unresolved atomic type)"); 215 break; 216 case eEncodingIsTypedefUID: 217 s->PutCString(" (unresolved typedef)"); 218 break; 219 case eEncodingIsPointerUID: 220 s->PutCString(" (unresolved pointer)"); 221 break; 222 case eEncodingIsLValueReferenceUID: 223 s->PutCString(" (unresolved L value reference)"); 224 break; 225 case eEncodingIsRValueReferenceUID: 226 s->PutCString(" (unresolved R value reference)"); 227 break; 228 case eEncodingIsSyntheticUID: 229 s->PutCString(" (synthetic type)"); 230 break; 231 } 232 } 233 } 234 235 void Type::Dump(Stream *s, bool show_context, lldb::DescriptionLevel level) { 236 s->Printf("%p: ", static_cast<void *>(this)); 237 s->Indent(); 238 *s << "Type" << static_cast<const UserID &>(*this) << ' '; 239 if (m_name) 240 *s << ", name = \"" << m_name << "\""; 241 242 if (m_byte_size_has_value) 243 s->Printf(", size = %" PRIu64, m_byte_size); 244 245 if (show_context && m_context != nullptr) { 246 s->PutCString(", context = ( "); 247 m_context->DumpSymbolContext(s); 248 s->PutCString(" )"); 249 } 250 251 bool show_fullpaths = false; 252 m_decl.Dump(s, show_fullpaths); 253 254 if (m_compiler_type.IsValid()) { 255 *s << ", compiler_type = " << m_compiler_type.GetOpaqueQualType() << ' '; 256 GetForwardCompilerType().DumpTypeDescription(s, level); 257 } else if (m_encoding_uid != LLDB_INVALID_UID) { 258 s->Format(", type_data = {0:x-16}", m_encoding_uid); 259 switch (m_encoding_uid_type) { 260 case eEncodingInvalid: 261 break; 262 case eEncodingIsUID: 263 s->PutCString(" (unresolved type)"); 264 break; 265 case eEncodingIsConstUID: 266 s->PutCString(" (unresolved const type)"); 267 break; 268 case eEncodingIsRestrictUID: 269 s->PutCString(" (unresolved restrict type)"); 270 break; 271 case eEncodingIsVolatileUID: 272 s->PutCString(" (unresolved volatile type)"); 273 break; 274 case eEncodingIsAtomicUID: 275 s->PutCString(" (unresolved atomic type)"); 276 break; 277 case eEncodingIsTypedefUID: 278 s->PutCString(" (unresolved typedef)"); 279 break; 280 case eEncodingIsPointerUID: 281 s->PutCString(" (unresolved pointer)"); 282 break; 283 case eEncodingIsLValueReferenceUID: 284 s->PutCString(" (unresolved L value reference)"); 285 break; 286 case eEncodingIsRValueReferenceUID: 287 s->PutCString(" (unresolved R value reference)"); 288 break; 289 case eEncodingIsSyntheticUID: 290 s->PutCString(" (synthetic type)"); 291 break; 292 } 293 } 294 295 // 296 // if (m_access) 297 // s->Printf(", access = %u", m_access); 298 s->EOL(); 299 } 300 301 ConstString Type::GetName() { 302 if (!m_name) 303 m_name = GetForwardCompilerType().GetTypeName(); 304 return m_name; 305 } 306 307 void Type::DumpTypeName(Stream *s) { GetName().Dump(s, "<invalid-type-name>"); } 308 309 void Type::DumpValue(ExecutionContext *exe_ctx, Stream *s, 310 const DataExtractor &data, uint32_t data_byte_offset, 311 bool show_types, bool show_summary, bool verbose, 312 lldb::Format format) { 313 if (ResolveCompilerType(ResolveState::Forward)) { 314 if (show_types) { 315 s->PutChar('('); 316 if (verbose) 317 s->Printf("Type{0x%8.8" PRIx64 "} ", GetID()); 318 DumpTypeName(s); 319 s->PutCString(") "); 320 } 321 322 GetForwardCompilerType().DumpValue( 323 exe_ctx, s, format == lldb::eFormatDefault ? GetFormat() : format, data, 324 data_byte_offset, 325 GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr) 326 .getValueOr(0), 327 0, // Bitfield bit size 328 0, // Bitfield bit offset 329 show_types, show_summary, verbose, 0); 330 } 331 } 332 333 Type *Type::GetEncodingType() { 334 if (m_encoding_type == nullptr && m_encoding_uid != LLDB_INVALID_UID) 335 m_encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid); 336 return m_encoding_type; 337 } 338 339 llvm::Optional<uint64_t> Type::GetByteSize(ExecutionContextScope *exe_scope) { 340 if (m_byte_size_has_value) 341 return m_byte_size; 342 343 switch (m_encoding_uid_type) { 344 case eEncodingInvalid: 345 case eEncodingIsSyntheticUID: 346 break; 347 case eEncodingIsUID: 348 case eEncodingIsConstUID: 349 case eEncodingIsRestrictUID: 350 case eEncodingIsVolatileUID: 351 case eEncodingIsAtomicUID: 352 case eEncodingIsTypedefUID: { 353 Type *encoding_type = GetEncodingType(); 354 if (encoding_type) 355 if (llvm::Optional<uint64_t> size = encoding_type->GetByteSize(exe_scope)) { 356 m_byte_size = *size; 357 m_byte_size_has_value = true; 358 return m_byte_size; 359 } 360 361 if (llvm::Optional<uint64_t> size = 362 GetLayoutCompilerType().GetByteSize(exe_scope)) { 363 m_byte_size = *size; 364 m_byte_size_has_value = true; 365 return m_byte_size; 366 } 367 } break; 368 369 // If we are a pointer or reference, then this is just a pointer size; 370 case eEncodingIsPointerUID: 371 case eEncodingIsLValueReferenceUID: 372 case eEncodingIsRValueReferenceUID: { 373 if (ArchSpec arch = m_symbol_file->GetObjectFile()->GetArchitecture()) { 374 m_byte_size = arch.GetAddressByteSize(); 375 m_byte_size_has_value = true; 376 return m_byte_size; 377 } 378 } break; 379 } 380 return {}; 381 } 382 383 uint32_t Type::GetNumChildren(bool omit_empty_base_classes) { 384 return GetForwardCompilerType().GetNumChildren(omit_empty_base_classes, nullptr); 385 } 386 387 bool Type::IsAggregateType() { 388 return GetForwardCompilerType().IsAggregateType(); 389 } 390 391 lldb::TypeSP Type::GetTypedefType() { 392 lldb::TypeSP type_sp; 393 if (IsTypedef()) { 394 Type *typedef_type = m_symbol_file->ResolveTypeUID(m_encoding_uid); 395 if (typedef_type) 396 type_sp = typedef_type->shared_from_this(); 397 } 398 return type_sp; 399 } 400 401 lldb::Format Type::GetFormat() { return GetForwardCompilerType().GetFormat(); } 402 403 lldb::Encoding Type::GetEncoding(uint64_t &count) { 404 // Make sure we resolve our type if it already hasn't been. 405 return GetForwardCompilerType().GetEncoding(count); 406 } 407 408 bool Type::DumpValueInMemory(ExecutionContext *exe_ctx, Stream *s, 409 lldb::addr_t address, AddressType address_type, 410 bool show_types, bool show_summary, bool verbose) { 411 if (address != LLDB_INVALID_ADDRESS) { 412 DataExtractor data; 413 Target *target = nullptr; 414 if (exe_ctx) 415 target = exe_ctx->GetTargetPtr(); 416 if (target) 417 data.SetByteOrder(target->GetArchitecture().GetByteOrder()); 418 if (ReadFromMemory(exe_ctx, address, address_type, data)) { 419 DumpValue(exe_ctx, s, data, 0, show_types, show_summary, verbose); 420 return true; 421 } 422 } 423 return false; 424 } 425 426 bool Type::ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t addr, 427 AddressType address_type, DataExtractor &data) { 428 if (address_type == eAddressTypeFile) { 429 // Can't convert a file address to anything valid without more context 430 // (which Module it came from) 431 return false; 432 } 433 434 const uint64_t byte_size = 435 GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr) 436 .getValueOr(0); 437 if (data.GetByteSize() < byte_size) { 438 lldb::DataBufferSP data_sp(new DataBufferHeap(byte_size, '\0')); 439 data.SetData(data_sp); 440 } 441 442 uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, byte_size)); 443 if (dst != nullptr) { 444 if (address_type == eAddressTypeHost) { 445 // The address is an address in this process, so just copy it 446 if (addr == 0) 447 return false; 448 memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size); 449 return true; 450 } else { 451 if (exe_ctx) { 452 Process *process = exe_ctx->GetProcessPtr(); 453 if (process) { 454 Status error; 455 return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size, 456 error) == byte_size; 457 } 458 } 459 } 460 } 461 return false; 462 } 463 464 bool Type::WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t addr, 465 AddressType address_type, DataExtractor &data) { 466 return false; 467 } 468 469 const Declaration &Type::GetDeclaration() const { return m_decl; } 470 471 bool Type::ResolveCompilerType(ResolveState compiler_type_resolve_state) { 472 // TODO: This needs to consider the correct type system to use. 473 Type *encoding_type = nullptr; 474 if (!m_compiler_type.IsValid()) { 475 encoding_type = GetEncodingType(); 476 if (encoding_type) { 477 switch (m_encoding_uid_type) { 478 case eEncodingIsUID: { 479 CompilerType encoding_compiler_type = 480 encoding_type->GetForwardCompilerType(); 481 if (encoding_compiler_type.IsValid()) { 482 m_compiler_type = encoding_compiler_type; 483 m_compiler_type_resolve_state = 484 encoding_type->m_compiler_type_resolve_state; 485 } 486 } break; 487 488 case eEncodingIsConstUID: 489 m_compiler_type = 490 encoding_type->GetForwardCompilerType().AddConstModifier(); 491 break; 492 493 case eEncodingIsRestrictUID: 494 m_compiler_type = 495 encoding_type->GetForwardCompilerType().AddRestrictModifier(); 496 break; 497 498 case eEncodingIsVolatileUID: 499 m_compiler_type = 500 encoding_type->GetForwardCompilerType().AddVolatileModifier(); 501 break; 502 503 case eEncodingIsAtomicUID: 504 m_compiler_type = 505 encoding_type->GetForwardCompilerType().GetAtomicType(); 506 break; 507 508 case eEncodingIsTypedefUID: 509 m_compiler_type = encoding_type->GetForwardCompilerType().CreateTypedef( 510 m_name.AsCString("__lldb_invalid_typedef_name"), 511 GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload); 512 m_name.Clear(); 513 break; 514 515 case eEncodingIsPointerUID: 516 m_compiler_type = 517 encoding_type->GetForwardCompilerType().GetPointerType(); 518 break; 519 520 case eEncodingIsLValueReferenceUID: 521 m_compiler_type = 522 encoding_type->GetForwardCompilerType().GetLValueReferenceType(); 523 break; 524 525 case eEncodingIsRValueReferenceUID: 526 m_compiler_type = 527 encoding_type->GetForwardCompilerType().GetRValueReferenceType(); 528 break; 529 530 default: 531 llvm_unreachable("Unhandled encoding_data_type."); 532 } 533 } else { 534 // We have no encoding type, return void? 535 auto type_system_or_err = 536 m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC); 537 if (auto err = type_system_or_err.takeError()) { 538 LLDB_LOG_ERROR( 539 lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), 540 std::move(err), 541 "Unable to construct void type from TypeSystemClang"); 542 } else { 543 CompilerType void_compiler_type = 544 type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid); 545 switch (m_encoding_uid_type) { 546 case eEncodingIsUID: 547 m_compiler_type = void_compiler_type; 548 break; 549 550 case eEncodingIsConstUID: 551 m_compiler_type = void_compiler_type.AddConstModifier(); 552 break; 553 554 case eEncodingIsRestrictUID: 555 m_compiler_type = void_compiler_type.AddRestrictModifier(); 556 break; 557 558 case eEncodingIsVolatileUID: 559 m_compiler_type = void_compiler_type.AddVolatileModifier(); 560 break; 561 562 case eEncodingIsAtomicUID: 563 m_compiler_type = void_compiler_type.GetAtomicType(); 564 break; 565 566 case eEncodingIsTypedefUID: 567 m_compiler_type = void_compiler_type.CreateTypedef( 568 m_name.AsCString("__lldb_invalid_typedef_name"), 569 GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload); 570 break; 571 572 case eEncodingIsPointerUID: 573 m_compiler_type = void_compiler_type.GetPointerType(); 574 break; 575 576 case eEncodingIsLValueReferenceUID: 577 m_compiler_type = void_compiler_type.GetLValueReferenceType(); 578 break; 579 580 case eEncodingIsRValueReferenceUID: 581 m_compiler_type = void_compiler_type.GetRValueReferenceType(); 582 break; 583 584 default: 585 llvm_unreachable("Unhandled encoding_data_type."); 586 } 587 } 588 } 589 590 // When we have a EncodingUID, our "m_flags.compiler_type_resolve_state" is 591 // set to eResolveStateUnresolved so we need to update it to say that we 592 // now have a forward declaration since that is what we created above. 593 if (m_compiler_type.IsValid()) 594 m_compiler_type_resolve_state = ResolveState::Forward; 595 } 596 597 // Check if we have a forward reference to a class/struct/union/enum? 598 if (compiler_type_resolve_state == ResolveState::Layout || 599 compiler_type_resolve_state == ResolveState::Full) { 600 // Check if we have a forward reference to a class/struct/union/enum? 601 if (m_compiler_type.IsValid() && 602 m_compiler_type_resolve_state < compiler_type_resolve_state) { 603 m_compiler_type_resolve_state = ResolveState::Full; 604 if (!m_compiler_type.IsDefined()) { 605 // We have a forward declaration, we need to resolve it to a complete 606 // definition. 607 m_symbol_file->CompleteType(m_compiler_type); 608 } 609 } 610 } 611 612 // If we have an encoding type, then we need to make sure it is resolved 613 // appropriately. 614 if (m_encoding_uid != LLDB_INVALID_UID) { 615 if (encoding_type == nullptr) 616 encoding_type = GetEncodingType(); 617 if (encoding_type) { 618 ResolveState encoding_compiler_type_resolve_state = 619 compiler_type_resolve_state; 620 621 if (compiler_type_resolve_state == ResolveState::Layout) { 622 switch (m_encoding_uid_type) { 623 case eEncodingIsPointerUID: 624 case eEncodingIsLValueReferenceUID: 625 case eEncodingIsRValueReferenceUID: 626 encoding_compiler_type_resolve_state = ResolveState::Forward; 627 break; 628 default: 629 break; 630 } 631 } 632 encoding_type->ResolveCompilerType(encoding_compiler_type_resolve_state); 633 } 634 } 635 return m_compiler_type.IsValid(); 636 } 637 uint32_t Type::GetEncodingMask() { 638 uint32_t encoding_mask = 1u << m_encoding_uid_type; 639 Type *encoding_type = GetEncodingType(); 640 assert(encoding_type != this); 641 if (encoding_type) 642 encoding_mask |= encoding_type->GetEncodingMask(); 643 return encoding_mask; 644 } 645 646 CompilerType Type::GetFullCompilerType() { 647 ResolveCompilerType(ResolveState::Full); 648 return m_compiler_type; 649 } 650 651 CompilerType Type::GetLayoutCompilerType() { 652 ResolveCompilerType(ResolveState::Layout); 653 return m_compiler_type; 654 } 655 656 CompilerType Type::GetForwardCompilerType() { 657 ResolveCompilerType(ResolveState::Forward); 658 return m_compiler_type; 659 } 660 661 ConstString Type::GetQualifiedName() { 662 return GetForwardCompilerType().GetTypeName(); 663 } 664 665 bool Type::GetTypeScopeAndBasename(llvm::StringRef name, 666 llvm::StringRef &scope, 667 llvm::StringRef &basename, 668 TypeClass &type_class) { 669 type_class = eTypeClassAny; 670 671 if (name.empty()) 672 return false; 673 674 basename = name; 675 if (basename.consume_front("struct ")) 676 type_class = eTypeClassStruct; 677 else if (basename.consume_front("class ")) 678 type_class = eTypeClassClass; 679 else if (basename.consume_front("union ")) 680 type_class = eTypeClassUnion; 681 else if (basename.consume_front("enum ")) 682 type_class = eTypeClassEnumeration; 683 else if (basename.consume_front("typedef ")) 684 type_class = eTypeClassTypedef; 685 686 size_t namespace_separator = basename.find("::"); 687 if (namespace_separator == llvm::StringRef::npos) 688 return false; 689 690 size_t template_begin = basename.find('<'); 691 while (namespace_separator != llvm::StringRef::npos) { 692 if (template_begin != llvm::StringRef::npos && 693 namespace_separator > template_begin) { 694 size_t template_depth = 1; 695 llvm::StringRef template_arg = 696 basename.drop_front(template_begin + 1); 697 while (template_depth > 0 && !template_arg.empty()) { 698 if (template_arg.front() == '<') 699 template_depth++; 700 else if (template_arg.front() == '>') 701 template_depth--; 702 template_arg = template_arg.drop_front(1); 703 } 704 if (template_depth != 0) 705 return false; // We have an invalid type name. Bail out. 706 if (template_arg.empty()) 707 break; // The template ends at the end of the full name. 708 basename = template_arg; 709 } else { 710 basename = basename.drop_front(namespace_separator + 2); 711 } 712 template_begin = basename.find('<'); 713 namespace_separator = basename.find("::"); 714 } 715 if (basename.size() < name.size()) { 716 scope = name.take_front(name.size() - basename.size()); 717 return true; 718 } 719 return false; 720 } 721 722 ModuleSP Type::GetModule() { 723 if (m_symbol_file) 724 return m_symbol_file->GetObjectFile()->GetModule(); 725 return ModuleSP(); 726 } 727 728 ModuleSP Type::GetExeModule() { 729 if (m_compiler_type) { 730 SymbolFile *symbol_file = m_compiler_type.GetTypeSystem()->GetSymbolFile(); 731 if (symbol_file) 732 return symbol_file->GetObjectFile()->GetModule(); 733 } 734 return ModuleSP(); 735 } 736 737 TypeAndOrName::TypeAndOrName(TypeSP &in_type_sp) { 738 if (in_type_sp) { 739 m_compiler_type = in_type_sp->GetForwardCompilerType(); 740 m_type_name = in_type_sp->GetName(); 741 } 742 } 743 744 TypeAndOrName::TypeAndOrName(const char *in_type_str) 745 : m_type_name(in_type_str) {} 746 747 TypeAndOrName::TypeAndOrName(ConstString &in_type_const_string) 748 : m_type_name(in_type_const_string) {} 749 750 bool TypeAndOrName::operator==(const TypeAndOrName &other) const { 751 if (m_compiler_type != other.m_compiler_type) 752 return false; 753 if (m_type_name != other.m_type_name) 754 return false; 755 return true; 756 } 757 758 bool TypeAndOrName::operator!=(const TypeAndOrName &other) const { 759 return !(*this == other); 760 } 761 762 ConstString TypeAndOrName::GetName() const { 763 if (m_type_name) 764 return m_type_name; 765 if (m_compiler_type) 766 return m_compiler_type.GetTypeName(); 767 return ConstString("<invalid>"); 768 } 769 770 void TypeAndOrName::SetName(ConstString type_name) { 771 m_type_name = type_name; 772 } 773 774 void TypeAndOrName::SetName(const char *type_name_cstr) { 775 m_type_name.SetCString(type_name_cstr); 776 } 777 778 void TypeAndOrName::SetTypeSP(lldb::TypeSP type_sp) { 779 if (type_sp) { 780 m_compiler_type = type_sp->GetForwardCompilerType(); 781 m_type_name = type_sp->GetName(); 782 } else 783 Clear(); 784 } 785 786 void TypeAndOrName::SetCompilerType(CompilerType compiler_type) { 787 m_compiler_type = compiler_type; 788 if (m_compiler_type) 789 m_type_name = m_compiler_type.GetTypeName(); 790 } 791 792 bool TypeAndOrName::IsEmpty() const { 793 return !((bool)m_type_name || (bool)m_compiler_type); 794 } 795 796 void TypeAndOrName::Clear() { 797 m_type_name.Clear(); 798 m_compiler_type.Clear(); 799 } 800 801 bool TypeAndOrName::HasName() const { return (bool)m_type_name; } 802 803 bool TypeAndOrName::HasCompilerType() const { 804 return m_compiler_type.IsValid(); 805 } 806 807 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp) 808 : m_module_wp(), m_static_type(), m_dynamic_type() { 809 SetType(type_sp); 810 } 811 812 TypeImpl::TypeImpl(const CompilerType &compiler_type) 813 : m_module_wp(), m_static_type(), m_dynamic_type() { 814 SetType(compiler_type); 815 } 816 817 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic) 818 : m_module_wp(), m_static_type(), m_dynamic_type(dynamic) { 819 SetType(type_sp, dynamic); 820 } 821 822 TypeImpl::TypeImpl(const CompilerType &static_type, 823 const CompilerType &dynamic_type) 824 : m_module_wp(), m_static_type(), m_dynamic_type() { 825 SetType(static_type, dynamic_type); 826 } 827 828 void TypeImpl::SetType(const lldb::TypeSP &type_sp) { 829 if (type_sp) { 830 m_static_type = type_sp->GetForwardCompilerType(); 831 m_exe_module_wp = type_sp->GetExeModule(); 832 m_module_wp = type_sp->GetModule(); 833 } else { 834 m_static_type.Clear(); 835 m_module_wp = lldb::ModuleWP(); 836 } 837 } 838 839 void TypeImpl::SetType(const CompilerType &compiler_type) { 840 m_module_wp = lldb::ModuleWP(); 841 m_static_type = compiler_type; 842 } 843 844 void TypeImpl::SetType(const lldb::TypeSP &type_sp, 845 const CompilerType &dynamic) { 846 SetType(type_sp); 847 m_dynamic_type = dynamic; 848 } 849 850 void TypeImpl::SetType(const CompilerType &compiler_type, 851 const CompilerType &dynamic) { 852 m_module_wp = lldb::ModuleWP(); 853 m_static_type = compiler_type; 854 m_dynamic_type = dynamic; 855 } 856 857 bool TypeImpl::CheckModule(lldb::ModuleSP &module_sp) const { 858 return CheckModuleCommon(m_module_wp, module_sp); 859 } 860 861 bool TypeImpl::CheckExeModule(lldb::ModuleSP &module_sp) const { 862 return CheckModuleCommon(m_exe_module_wp, module_sp); 863 } 864 865 bool TypeImpl::CheckModuleCommon(const lldb::ModuleWP &input_module_wp, 866 lldb::ModuleSP &module_sp) const { 867 // Check if we have a module for this type. If we do and the shared pointer 868 // is can be successfully initialized with m_module_wp, return true. Else 869 // return false if we didn't have a module, or if we had a module and it has 870 // been deleted. Any functions doing anything with a TypeSP in this TypeImpl 871 // class should call this function and only do anything with the ivars if 872 // this function returns true. If we have a module, the "module_sp" will be 873 // filled in with a strong reference to the module so that the module will at 874 // least stay around long enough for the type query to succeed. 875 module_sp = input_module_wp.lock(); 876 if (!module_sp) { 877 lldb::ModuleWP empty_module_wp; 878 // If either call to "std::weak_ptr::owner_before(...) value returns true, 879 // this indicates that m_module_wp once contained (possibly still does) a 880 // reference to a valid shared pointer. This helps us know if we had a 881 // valid reference to a section which is now invalid because the module it 882 // was in was deleted 883 if (empty_module_wp.owner_before(input_module_wp) || 884 input_module_wp.owner_before(empty_module_wp)) { 885 // input_module_wp had a valid reference to a module, but all strong 886 // references have been released and the module has been deleted 887 return false; 888 } 889 } 890 // We either successfully locked the module, or didn't have one to begin with 891 return true; 892 } 893 894 bool TypeImpl::operator==(const TypeImpl &rhs) const { 895 return m_static_type == rhs.m_static_type && 896 m_dynamic_type == rhs.m_dynamic_type; 897 } 898 899 bool TypeImpl::operator!=(const TypeImpl &rhs) const { 900 return !(*this == rhs); 901 } 902 903 bool TypeImpl::IsValid() const { 904 // just a name is not valid 905 ModuleSP module_sp; 906 if (CheckModule(module_sp)) 907 return m_static_type.IsValid() || m_dynamic_type.IsValid(); 908 return false; 909 } 910 911 TypeImpl::operator bool() const { return IsValid(); } 912 913 void TypeImpl::Clear() { 914 m_module_wp = lldb::ModuleWP(); 915 m_static_type.Clear(); 916 m_dynamic_type.Clear(); 917 } 918 919 ModuleSP TypeImpl::GetModule() const { 920 lldb::ModuleSP module_sp; 921 if (CheckExeModule(module_sp)) 922 return module_sp; 923 return nullptr; 924 } 925 926 ConstString TypeImpl::GetName() const { 927 ModuleSP module_sp; 928 if (CheckModule(module_sp)) { 929 if (m_dynamic_type) 930 return m_dynamic_type.GetTypeName(); 931 return m_static_type.GetTypeName(); 932 } 933 return ConstString(); 934 } 935 936 ConstString TypeImpl::GetDisplayTypeName() const { 937 ModuleSP module_sp; 938 if (CheckModule(module_sp)) { 939 if (m_dynamic_type) 940 return m_dynamic_type.GetDisplayTypeName(); 941 return m_static_type.GetDisplayTypeName(); 942 } 943 return ConstString(); 944 } 945 946 TypeImpl TypeImpl::GetPointerType() const { 947 ModuleSP module_sp; 948 if (CheckModule(module_sp)) { 949 if (m_dynamic_type.IsValid()) { 950 return TypeImpl(m_static_type.GetPointerType(), 951 m_dynamic_type.GetPointerType()); 952 } 953 return TypeImpl(m_static_type.GetPointerType()); 954 } 955 return TypeImpl(); 956 } 957 958 TypeImpl TypeImpl::GetPointeeType() const { 959 ModuleSP module_sp; 960 if (CheckModule(module_sp)) { 961 if (m_dynamic_type.IsValid()) { 962 return TypeImpl(m_static_type.GetPointeeType(), 963 m_dynamic_type.GetPointeeType()); 964 } 965 return TypeImpl(m_static_type.GetPointeeType()); 966 } 967 return TypeImpl(); 968 } 969 970 TypeImpl TypeImpl::GetReferenceType() const { 971 ModuleSP module_sp; 972 if (CheckModule(module_sp)) { 973 if (m_dynamic_type.IsValid()) { 974 return TypeImpl(m_static_type.GetLValueReferenceType(), 975 m_dynamic_type.GetLValueReferenceType()); 976 } 977 return TypeImpl(m_static_type.GetLValueReferenceType()); 978 } 979 return TypeImpl(); 980 } 981 982 TypeImpl TypeImpl::GetTypedefedType() const { 983 ModuleSP module_sp; 984 if (CheckModule(module_sp)) { 985 if (m_dynamic_type.IsValid()) { 986 return TypeImpl(m_static_type.GetTypedefedType(), 987 m_dynamic_type.GetTypedefedType()); 988 } 989 return TypeImpl(m_static_type.GetTypedefedType()); 990 } 991 return TypeImpl(); 992 } 993 994 TypeImpl TypeImpl::GetDereferencedType() const { 995 ModuleSP module_sp; 996 if (CheckModule(module_sp)) { 997 if (m_dynamic_type.IsValid()) { 998 return TypeImpl(m_static_type.GetNonReferenceType(), 999 m_dynamic_type.GetNonReferenceType()); 1000 } 1001 return TypeImpl(m_static_type.GetNonReferenceType()); 1002 } 1003 return TypeImpl(); 1004 } 1005 1006 TypeImpl TypeImpl::GetUnqualifiedType() const { 1007 ModuleSP module_sp; 1008 if (CheckModule(module_sp)) { 1009 if (m_dynamic_type.IsValid()) { 1010 return TypeImpl(m_static_type.GetFullyUnqualifiedType(), 1011 m_dynamic_type.GetFullyUnqualifiedType()); 1012 } 1013 return TypeImpl(m_static_type.GetFullyUnqualifiedType()); 1014 } 1015 return TypeImpl(); 1016 } 1017 1018 TypeImpl TypeImpl::GetCanonicalType() const { 1019 ModuleSP module_sp; 1020 if (CheckModule(module_sp)) { 1021 if (m_dynamic_type.IsValid()) { 1022 return TypeImpl(m_static_type.GetCanonicalType(), 1023 m_dynamic_type.GetCanonicalType()); 1024 } 1025 return TypeImpl(m_static_type.GetCanonicalType()); 1026 } 1027 return TypeImpl(); 1028 } 1029 1030 CompilerType TypeImpl::GetCompilerType(bool prefer_dynamic) { 1031 ModuleSP module_sp; 1032 if (CheckModule(module_sp)) { 1033 if (prefer_dynamic) { 1034 if (m_dynamic_type.IsValid()) 1035 return m_dynamic_type; 1036 } 1037 return m_static_type; 1038 } 1039 return CompilerType(); 1040 } 1041 1042 TypeSystem *TypeImpl::GetTypeSystem(bool prefer_dynamic) { 1043 ModuleSP module_sp; 1044 if (CheckModule(module_sp)) { 1045 if (prefer_dynamic) { 1046 if (m_dynamic_type.IsValid()) 1047 return m_dynamic_type.GetTypeSystem(); 1048 } 1049 return m_static_type.GetTypeSystem(); 1050 } 1051 return nullptr; 1052 } 1053 1054 bool TypeImpl::GetDescription(lldb_private::Stream &strm, 1055 lldb::DescriptionLevel description_level) { 1056 ModuleSP module_sp; 1057 if (CheckModule(module_sp)) { 1058 if (m_dynamic_type.IsValid()) { 1059 strm.Printf("Dynamic:\n"); 1060 m_dynamic_type.DumpTypeDescription(&strm); 1061 strm.Printf("\nStatic:\n"); 1062 } 1063 m_static_type.DumpTypeDescription(&strm); 1064 } else { 1065 strm.PutCString("Invalid TypeImpl module for type has been deleted\n"); 1066 } 1067 return true; 1068 } 1069 1070 bool TypeMemberFunctionImpl::IsValid() { 1071 return m_type.IsValid() && m_kind != lldb::eMemberFunctionKindUnknown; 1072 } 1073 1074 ConstString TypeMemberFunctionImpl::GetName() const { return m_name; } 1075 1076 ConstString TypeMemberFunctionImpl::GetMangledName() const { 1077 return m_decl.GetMangledName(); 1078 } 1079 1080 CompilerType TypeMemberFunctionImpl::GetType() const { return m_type; } 1081 1082 lldb::MemberFunctionKind TypeMemberFunctionImpl::GetKind() const { 1083 return m_kind; 1084 } 1085 1086 bool TypeMemberFunctionImpl::GetDescription(Stream &stream) { 1087 switch (m_kind) { 1088 case lldb::eMemberFunctionKindUnknown: 1089 return false; 1090 case lldb::eMemberFunctionKindConstructor: 1091 stream.Printf("constructor for %s", 1092 m_type.GetTypeName().AsCString("<unknown>")); 1093 break; 1094 case lldb::eMemberFunctionKindDestructor: 1095 stream.Printf("destructor for %s", 1096 m_type.GetTypeName().AsCString("<unknown>")); 1097 break; 1098 case lldb::eMemberFunctionKindInstanceMethod: 1099 stream.Printf("instance method %s of type %s", m_name.AsCString(), 1100 m_decl.GetDeclContext().GetName().AsCString()); 1101 break; 1102 case lldb::eMemberFunctionKindStaticMethod: 1103 stream.Printf("static method %s of type %s", m_name.AsCString(), 1104 m_decl.GetDeclContext().GetName().AsCString()); 1105 break; 1106 } 1107 return true; 1108 } 1109 1110 CompilerType TypeMemberFunctionImpl::GetReturnType() const { 1111 if (m_type) 1112 return m_type.GetFunctionReturnType(); 1113 return m_decl.GetFunctionReturnType(); 1114 } 1115 1116 size_t TypeMemberFunctionImpl::GetNumArguments() const { 1117 if (m_type) 1118 return m_type.GetNumberOfFunctionArguments(); 1119 else 1120 return m_decl.GetNumFunctionArguments(); 1121 } 1122 1123 CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const { 1124 if (m_type) 1125 return m_type.GetFunctionArgumentAtIndex(idx); 1126 else 1127 return m_decl.GetFunctionArgumentType(idx); 1128 } 1129 1130 TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp, 1131 ConstString name, 1132 const llvm::APSInt &value) 1133 : m_integer_type_sp(integer_type_sp), m_name(name), m_value(value), 1134 m_valid((bool)name && (bool)integer_type_sp) 1135 1136 {} 1137