1 //===-- Type.cpp ------------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // Other libraries and framework includes 11 12 #include "lldb/Core/DataExtractor.h" 13 #include "lldb/Core/DataBufferHeap.h" 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/Scalar.h" 16 #include "lldb/Core/StreamString.h" 17 18 #include "lldb/Symbol/ClangASTType.h" 19 #include "lldb/Symbol/ClangASTContext.h" 20 #include "lldb/Symbol/ObjectFile.h" 21 #include "lldb/Symbol/SymbolContextScope.h" 22 #include "lldb/Symbol/SymbolFile.h" 23 #include "lldb/Symbol/SymbolVendor.h" 24 #include "lldb/Symbol/Type.h" 25 #include "lldb/Symbol/TypeList.h" 26 27 #include "lldb/Target/ExecutionContext.h" 28 #include "lldb/Target/Process.h" 29 #include "lldb/Target/Target.h" 30 31 using namespace lldb; 32 using namespace lldb_private; 33 34 Type * 35 SymbolFileType::GetType () 36 { 37 if (!m_type_sp) 38 { 39 Type *resolved_type = m_symbol_file.ResolveTypeUID (GetID()); 40 if (resolved_type) 41 m_type_sp = resolved_type->shared_from_this(); 42 } 43 return m_type_sp.get(); 44 } 45 46 47 Type::Type 48 ( 49 lldb::user_id_t uid, 50 SymbolFile* symbol_file, 51 const ConstString &name, 52 uint32_t byte_size, 53 SymbolContextScope *context, 54 user_id_t encoding_uid, 55 EncodingDataType encoding_uid_type, 56 const Declaration& decl, 57 clang_type_t clang_type, 58 ResolveState clang_type_resolve_state 59 ) : 60 UserID (uid), 61 m_name (name), 62 m_symbol_file (symbol_file), 63 m_context (context), 64 m_encoding_type (NULL), 65 m_encoding_uid (encoding_uid), 66 m_encoding_uid_type (encoding_uid_type), 67 m_byte_size (byte_size), 68 m_decl (decl), 69 m_clang_type (clang_type) 70 { 71 m_flags.clang_type_resolve_state = (clang_type ? clang_type_resolve_state : eResolveStateUnresolved); 72 m_flags.is_complete_objc_class = false; 73 } 74 75 Type::Type () : 76 UserID (0), 77 m_name ("<INVALID TYPE>"), 78 m_symbol_file (NULL), 79 m_context (NULL), 80 m_encoding_type (NULL), 81 m_encoding_uid (0), 82 m_encoding_uid_type (eEncodingInvalid), 83 m_byte_size (0), 84 m_decl (), 85 m_clang_type (NULL) 86 { 87 m_flags.clang_type_resolve_state = eResolveStateUnresolved; 88 m_flags.is_complete_objc_class = false; 89 } 90 91 92 Type::Type (const Type &rhs) : 93 UserID (rhs), 94 m_name (rhs.m_name), 95 m_symbol_file (rhs.m_symbol_file), 96 m_context (rhs.m_context), 97 m_encoding_type (rhs.m_encoding_type), 98 m_encoding_uid (rhs.m_encoding_uid), 99 m_encoding_uid_type (rhs.m_encoding_uid_type), 100 m_byte_size (rhs.m_byte_size), 101 m_decl (rhs.m_decl), 102 m_clang_type (rhs.m_clang_type), 103 m_flags (rhs.m_flags) 104 { 105 } 106 107 const Type& 108 Type::operator= (const Type& rhs) 109 { 110 if (this != &rhs) 111 { 112 } 113 return *this; 114 } 115 116 117 void 118 Type::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name) 119 { 120 *s << "id = " << (const UserID&)*this; 121 122 // Call the name accessor to make sure we resolve the type name 123 if (show_name) 124 { 125 const ConstString &type_name = GetName(); 126 if (type_name) 127 { 128 *s << ", name = \"" << type_name << '"'; 129 ConstString qualified_type_name (GetQualifiedName()); 130 if (qualified_type_name != type_name) 131 { 132 *s << ", qualified = \"" << qualified_type_name << '"'; 133 } 134 } 135 } 136 137 // Call the get byte size accesor so we resolve our byte size 138 if (GetByteSize()) 139 s->Printf(", byte-size = %u", m_byte_size); 140 bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose); 141 m_decl.Dump(s, show_fullpaths); 142 143 if (m_clang_type) 144 { 145 *s << ", clang_type = \""; 146 ClangASTType::DumpTypeDescription (GetClangAST(), m_clang_type, s); 147 *s << '"'; 148 } 149 else if (m_encoding_uid != LLDB_INVALID_UID) 150 { 151 s->Printf(", type_uid = 0x%8.8x", m_encoding_uid); 152 switch (m_encoding_uid_type) 153 { 154 case eEncodingInvalid: break; 155 case eEncodingIsUID: s->PutCString(" (unresolved type)"); break; 156 case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break; 157 case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break; 158 case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break; 159 case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break; 160 case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break; 161 case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break; 162 case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break; 163 case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break; 164 } 165 } 166 } 167 168 169 void 170 Type::Dump (Stream *s, bool show_context) 171 { 172 s->Printf("%p: ", this); 173 s->Indent(); 174 *s << "Type" << (const UserID&)*this << ' '; 175 if (m_name) 176 *s << ", name = \"" << m_name << "\""; 177 178 if (m_byte_size != 0) 179 s->Printf(", size = %u", m_byte_size); 180 181 if (show_context && m_context != NULL) 182 { 183 s->PutCString(", context = ( "); 184 m_context->DumpSymbolContext(s); 185 s->PutCString(" )"); 186 } 187 188 bool show_fullpaths = false; 189 m_decl.Dump (s,show_fullpaths); 190 191 if (m_clang_type) 192 { 193 *s << ", clang_type = " << m_clang_type << ' '; 194 195 ClangASTType::DumpTypeDescription (GetClangAST(), m_clang_type, s); 196 } 197 else if (m_encoding_uid != LLDB_INVALID_UID) 198 { 199 *s << ", type_data = " << (uint64_t)m_encoding_uid; 200 switch (m_encoding_uid_type) 201 { 202 case eEncodingInvalid: break; 203 case eEncodingIsUID: s->PutCString(" (unresolved type)"); break; 204 case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break; 205 case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break; 206 case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break; 207 case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break; 208 case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break; 209 case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break; 210 case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break; 211 case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break; 212 } 213 } 214 215 // 216 // if (m_access) 217 // s->Printf(", access = %u", m_access); 218 s->EOL(); 219 } 220 221 const ConstString & 222 Type::GetName() 223 { 224 if (!m_name) 225 { 226 if (ResolveClangType(eResolveStateForward)) 227 m_name = ClangASTType::GetConstTypeName (GetClangASTContext ().getASTContext(), m_clang_type); 228 } 229 return m_name; 230 } 231 232 void 233 Type::DumpTypeName(Stream *s) 234 { 235 GetName().Dump(s, "<invalid-type-name>"); 236 } 237 238 239 void 240 Type::DumpValue 241 ( 242 ExecutionContext *exe_ctx, 243 Stream *s, 244 const DataExtractor &data, 245 uint32_t data_byte_offset, 246 bool show_types, 247 bool show_summary, 248 bool verbose, 249 lldb::Format format 250 ) 251 { 252 if (ResolveClangType(eResolveStateForward)) 253 { 254 if (show_types) 255 { 256 s->PutChar('('); 257 if (verbose) 258 s->Printf("Type{0x%8.8llx} ", GetID()); 259 DumpTypeName (s); 260 s->PutCString(") "); 261 } 262 263 ClangASTType::DumpValue (GetClangAST (), 264 m_clang_type, 265 exe_ctx, 266 s, 267 format == lldb::eFormatDefault ? GetFormat() : format, 268 data, 269 data_byte_offset, 270 GetByteSize(), 271 0, // Bitfield bit size 272 0, // Bitfield bit offset 273 show_types, 274 show_summary, 275 verbose, 276 0); 277 } 278 } 279 280 Type * 281 Type::GetEncodingType () 282 { 283 if (m_encoding_type == NULL && m_encoding_uid != LLDB_INVALID_UID) 284 m_encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid); 285 return m_encoding_type; 286 } 287 288 289 290 uint32_t 291 Type::GetByteSize() 292 { 293 if (m_byte_size == 0) 294 { 295 switch (m_encoding_uid_type) 296 { 297 case eEncodingInvalid: 298 case eEncodingIsSyntheticUID: 299 break; 300 case eEncodingIsUID: 301 case eEncodingIsConstUID: 302 case eEncodingIsRestrictUID: 303 case eEncodingIsVolatileUID: 304 case eEncodingIsTypedefUID: 305 { 306 Type *encoding_type = GetEncodingType (); 307 if (encoding_type) 308 m_byte_size = encoding_type->GetByteSize(); 309 if (m_byte_size == 0) 310 { 311 uint32_t bit_width = ClangASTType::GetClangTypeBitWidth (GetClangAST(), GetClangLayoutType()); 312 m_byte_size = (bit_width + 7 ) / 8; 313 } 314 } 315 break; 316 317 // If we are a pointer or reference, then this is just a pointer size; 318 case eEncodingIsPointerUID: 319 case eEncodingIsLValueReferenceUID: 320 case eEncodingIsRValueReferenceUID: 321 m_byte_size = m_symbol_file->GetClangASTContext().GetPointerBitSize() / 8; 322 break; 323 } 324 } 325 return m_byte_size; 326 } 327 328 329 uint32_t 330 Type::GetNumChildren (bool omit_empty_base_classes) 331 { 332 if (ResolveClangType(eResolveStateForward)) 333 { 334 return ClangASTContext::GetNumChildren (m_symbol_file->GetClangASTContext().getASTContext(), 335 m_clang_type, 336 omit_empty_base_classes); 337 } 338 return 0; 339 } 340 341 bool 342 Type::IsAggregateType () 343 { 344 if (ResolveClangType(eResolveStateForward)) 345 return ClangASTContext::IsAggregateType (m_clang_type); 346 return false; 347 } 348 349 lldb::Format 350 Type::GetFormat () 351 { 352 // Make sure we resolve our type if it already hasn't been. 353 if (!ResolveClangType(eResolveStateForward)) 354 return lldb::eFormatInvalid; 355 return ClangASTType::GetFormat (m_clang_type); 356 } 357 358 359 360 lldb::Encoding 361 Type::GetEncoding (uint32_t &count) 362 { 363 // Make sure we resolve our type if it already hasn't been. 364 if (!ResolveClangType(eResolveStateForward)) 365 return lldb::eEncodingInvalid; 366 367 return ClangASTType::GetEncoding (m_clang_type, count); 368 } 369 370 371 372 bool 373 Type::DumpValueInMemory 374 ( 375 ExecutionContext *exe_ctx, 376 Stream *s, 377 lldb::addr_t address, 378 AddressType address_type, 379 bool show_types, 380 bool show_summary, 381 bool verbose 382 ) 383 { 384 if (address != LLDB_INVALID_ADDRESS) 385 { 386 DataExtractor data; 387 Target *target = NULL; 388 if (exe_ctx) 389 target = exe_ctx->GetTargetPtr(); 390 if (target) 391 data.SetByteOrder (target->GetArchitecture().GetByteOrder()); 392 if (ReadFromMemory (exe_ctx, address, address_type, data)) 393 { 394 DumpValue(exe_ctx, s, data, 0, show_types, show_summary, verbose); 395 return true; 396 } 397 } 398 return false; 399 } 400 401 402 bool 403 Type::ReadFromMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data) 404 { 405 if (address_type == eAddressTypeFile) 406 { 407 // Can't convert a file address to anything valid without more 408 // context (which Module it came from) 409 return false; 410 } 411 412 const uint32_t byte_size = GetByteSize(); 413 if (data.GetByteSize() < byte_size) 414 { 415 lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); 416 data.SetData(data_sp); 417 } 418 419 uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); 420 if (dst != NULL) 421 { 422 if (address_type == eAddressTypeHost) 423 { 424 // The address is an address in this process, so just copy it 425 memcpy (dst, (uint8_t*)NULL + addr, byte_size); 426 return true; 427 } 428 else 429 { 430 if (exe_ctx) 431 { 432 Process *process = exe_ctx->GetProcessPtr(); 433 if (process) 434 { 435 Error error; 436 return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size, error) == byte_size; 437 } 438 } 439 } 440 } 441 return false; 442 } 443 444 445 bool 446 Type::WriteToMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data) 447 { 448 return false; 449 } 450 451 452 TypeList* 453 Type::GetTypeList() 454 { 455 return GetSymbolFile()->GetTypeList(); 456 } 457 458 const Declaration & 459 Type::GetDeclaration () const 460 { 461 return m_decl; 462 } 463 464 bool 465 Type::ResolveClangType (ResolveState clang_type_resolve_state) 466 { 467 Type *encoding_type = NULL; 468 if (m_clang_type == NULL) 469 { 470 encoding_type = GetEncodingType(); 471 if (encoding_type) 472 { 473 switch (m_encoding_uid_type) 474 { 475 case eEncodingIsUID: 476 if (encoding_type->ResolveClangType(clang_type_resolve_state)) 477 { 478 m_clang_type = encoding_type->m_clang_type; 479 m_flags.clang_type_resolve_state = encoding_type->m_flags.clang_type_resolve_state; 480 } 481 break; 482 483 case eEncodingIsConstUID: 484 m_clang_type = ClangASTContext::AddConstModifier (encoding_type->GetClangForwardType()); 485 break; 486 487 case eEncodingIsRestrictUID: 488 m_clang_type = ClangASTContext::AddRestrictModifier (encoding_type->GetClangForwardType()); 489 break; 490 491 case eEncodingIsVolatileUID: 492 m_clang_type = ClangASTContext::AddVolatileModifier (encoding_type->GetClangForwardType()); 493 break; 494 495 case eEncodingIsTypedefUID: 496 m_clang_type = CreateClangTypedefType (this, encoding_type); 497 // Clear the name so it can get fully qualified in case the 498 // typedef is in a namespace. 499 m_name.Clear(); 500 break; 501 502 case eEncodingIsPointerUID: 503 m_clang_type = CreateClangPointerType (encoding_type); 504 break; 505 506 case eEncodingIsLValueReferenceUID: 507 m_clang_type = CreateClangLValueReferenceType (encoding_type); 508 break; 509 510 case eEncodingIsRValueReferenceUID: 511 m_clang_type = CreateClangRValueReferenceType (encoding_type); 512 break; 513 514 default: 515 assert(!"Unhandled encoding_data_type."); 516 break; 517 } 518 } 519 else 520 { 521 // We have no encoding type, return void? 522 clang_type_t void_clang_type = GetClangASTContext().GetBuiltInType_void(); 523 switch (m_encoding_uid_type) 524 { 525 case eEncodingIsUID: 526 m_clang_type = void_clang_type; 527 break; 528 529 case eEncodingIsConstUID: 530 m_clang_type = ClangASTContext::AddConstModifier (void_clang_type); 531 break; 532 533 case eEncodingIsRestrictUID: 534 m_clang_type = ClangASTContext::AddRestrictModifier (void_clang_type); 535 break; 536 537 case eEncodingIsVolatileUID: 538 m_clang_type = ClangASTContext::AddVolatileModifier (void_clang_type); 539 break; 540 541 case eEncodingIsTypedefUID: 542 m_clang_type = GetClangASTContext().CreateTypedefType (m_name.AsCString(), void_clang_type, NULL); 543 break; 544 545 case eEncodingIsPointerUID: 546 m_clang_type = GetClangASTContext().CreatePointerType (void_clang_type); 547 break; 548 549 case eEncodingIsLValueReferenceUID: 550 m_clang_type = GetClangASTContext().CreateLValueReferenceType (void_clang_type); 551 break; 552 553 case eEncodingIsRValueReferenceUID: 554 m_clang_type = GetClangASTContext().CreateRValueReferenceType (void_clang_type); 555 break; 556 557 default: 558 assert(!"Unhandled encoding_data_type."); 559 break; 560 } 561 } 562 } 563 564 // Check if we have a forward reference to a class/struct/union/enum? 565 if (m_clang_type && m_flags.clang_type_resolve_state < clang_type_resolve_state) 566 { 567 m_flags.clang_type_resolve_state = eResolveStateFull; 568 if (!ClangASTType::IsDefined (m_clang_type)) 569 { 570 // We have a forward declaration, we need to resolve it to a complete 571 // definition. 572 m_symbol_file->ResolveClangOpaqueTypeDefinition (m_clang_type); 573 } 574 } 575 576 // If we have an encoding type, then we need to make sure it is 577 // resolved appropriately. 578 if (m_encoding_uid != LLDB_INVALID_UID) 579 { 580 if (encoding_type == NULL) 581 encoding_type = GetEncodingType(); 582 if (encoding_type) 583 { 584 ResolveState encoding_clang_type_resolve_state = clang_type_resolve_state; 585 586 if (clang_type_resolve_state == eResolveStateLayout) 587 { 588 switch (m_encoding_uid_type) 589 { 590 case eEncodingIsPointerUID: 591 case eEncodingIsLValueReferenceUID: 592 case eEncodingIsRValueReferenceUID: 593 encoding_clang_type_resolve_state = eResolveStateForward; 594 break; 595 default: 596 break; 597 } 598 } 599 encoding_type->ResolveClangType (encoding_clang_type_resolve_state); 600 } 601 } 602 return m_clang_type != NULL; 603 } 604 uint32_t 605 Type::GetEncodingMask () 606 { 607 uint32_t encoding_mask = 1u << m_encoding_uid_type; 608 Type *encoding_type = GetEncodingType(); 609 assert (encoding_type != this); 610 if (encoding_type) 611 encoding_mask |= encoding_type->GetEncodingMask (); 612 return encoding_mask; 613 } 614 615 clang_type_t 616 Type::GetClangFullType () 617 { 618 ResolveClangType(eResolveStateFull); 619 return m_clang_type; 620 } 621 622 clang_type_t 623 Type::GetClangLayoutType () 624 { 625 ResolveClangType(eResolveStateLayout); 626 return m_clang_type; 627 } 628 629 clang_type_t 630 Type::GetClangForwardType () 631 { 632 ResolveClangType (eResolveStateForward); 633 return m_clang_type; 634 } 635 636 clang::ASTContext * 637 Type::GetClangAST () 638 { 639 return GetClangASTContext().getASTContext(); 640 } 641 642 ClangASTContext & 643 Type::GetClangASTContext () 644 { 645 return m_symbol_file->GetClangASTContext(); 646 } 647 648 int 649 Type::Compare(const Type &a, const Type &b) 650 { 651 // Just compare the UID values for now... 652 lldb::user_id_t a_uid = a.GetID(); 653 lldb::user_id_t b_uid = b.GetID(); 654 if (a_uid < b_uid) 655 return -1; 656 if (a_uid > b_uid) 657 return 1; 658 return 0; 659 // if (a.getQualType() == b.getQualType()) 660 // return 0; 661 } 662 663 664 void * 665 Type::CreateClangPointerType (Type *type) 666 { 667 assert(type); 668 return GetClangASTContext().CreatePointerType(type->GetClangForwardType()); 669 } 670 671 void * 672 Type::CreateClangTypedefType (Type *typedef_type, Type *base_type) 673 { 674 assert(typedef_type && base_type); 675 return GetClangASTContext().CreateTypedefType (typedef_type->GetName().AsCString(), 676 base_type->GetClangForwardType(), 677 typedef_type->GetSymbolFile()->GetClangDeclContextContainingTypeUID(typedef_type->GetID())); 678 } 679 680 void * 681 Type::CreateClangLValueReferenceType (Type *type) 682 { 683 assert(type); 684 return GetClangASTContext().CreateLValueReferenceType(type->GetClangForwardType()); 685 } 686 687 void * 688 Type::CreateClangRValueReferenceType (Type *type) 689 { 690 assert(type); 691 return GetClangASTContext().CreateRValueReferenceType (type->GetClangForwardType()); 692 } 693 694 bool 695 Type::IsRealObjCClass() 696 { 697 // For now we are just skipping ObjC classes that get made by hand from the runtime, because 698 // those don't have any information. We could extend this to only return true for "full 699 // definitions" if we can figure that out. 700 701 if (ClangASTContext::IsObjCClassType(m_clang_type) && GetByteSize() != 0) 702 return true; 703 else 704 return false; 705 } 706 707 ConstString 708 Type::GetQualifiedName () 709 { 710 ConstString qualified_name (ClangASTType::GetTypeNameForOpaqueQualType (GetClangASTContext ().getASTContext(), GetClangForwardType()).c_str()); 711 return qualified_name; 712 } 713 714 715 bool 716 Type::GetTypeScopeAndBasename (const char* name_cstr, 717 std::string &scope, 718 std::string &basename) 719 { 720 // Protect against null c string. 721 722 if (name_cstr && name_cstr[0]) 723 { 724 const char *basename_cstr = name_cstr; 725 const char* namespace_separator = ::strstr (basename_cstr, "::"); 726 if (namespace_separator) 727 { 728 const char* template_arg_char = ::strchr (basename_cstr, '<'); 729 while (namespace_separator != NULL) 730 { 731 if (template_arg_char && namespace_separator > template_arg_char) // but namespace'd template arguments are still good to go 732 break; 733 basename_cstr = namespace_separator + 2; 734 namespace_separator = strstr(basename_cstr, "::"); 735 } 736 if (basename_cstr > name_cstr) 737 { 738 scope.assign (name_cstr, basename_cstr - name_cstr); 739 basename.assign (basename_cstr); 740 return true; 741 } 742 } 743 } 744 return false; 745 } 746 747 748 749 750 TypeAndOrName::TypeAndOrName () : m_type_sp(), m_type_name() 751 { 752 753 } 754 755 TypeAndOrName::TypeAndOrName (TypeSP &in_type_sp) : m_type_sp(in_type_sp) 756 { 757 if (in_type_sp) 758 m_type_name = in_type_sp->GetName(); 759 } 760 761 TypeAndOrName::TypeAndOrName (const char *in_type_str) : m_type_name(in_type_str) 762 { 763 } 764 765 TypeAndOrName::TypeAndOrName (const TypeAndOrName &rhs) : m_type_sp (rhs.m_type_sp), m_type_name (rhs.m_type_name) 766 { 767 768 } 769 770 TypeAndOrName::TypeAndOrName (ConstString &in_type_const_string) : m_type_name (in_type_const_string) 771 { 772 } 773 774 TypeAndOrName & 775 TypeAndOrName::operator= (const TypeAndOrName &rhs) 776 { 777 if (this != &rhs) 778 { 779 m_type_name = rhs.m_type_name; 780 m_type_sp = rhs.m_type_sp; 781 } 782 return *this; 783 } 784 785 ConstString 786 TypeAndOrName::GetName () const 787 { 788 if (m_type_sp) 789 return m_type_sp->GetName(); 790 else 791 return m_type_name; 792 } 793 794 void 795 TypeAndOrName::SetName (ConstString &type_name_const_str) 796 { 797 m_type_name = type_name_const_str; 798 } 799 800 void 801 TypeAndOrName::SetName (const char *type_name_str) 802 { 803 m_type_name.SetCString (type_name_str); 804 } 805 806 void 807 TypeAndOrName::SetTypeSP (lldb::TypeSP type_sp) 808 { 809 m_type_sp = type_sp; 810 if (type_sp) 811 m_type_name = type_sp->GetName(); 812 } 813 814 bool 815 TypeAndOrName::IsEmpty() 816 { 817 if (m_type_name || m_type_sp) 818 return false; 819 else 820 return true; 821 } 822 823 TypeImpl::TypeImpl(const lldb_private::ClangASTType& clang_ast_type) : 824 m_clang_ast_type(clang_ast_type.GetASTContext(), clang_ast_type.GetOpaqueQualType()), 825 m_type_sp() 826 {} 827 828 TypeImpl::TypeImpl(const lldb::TypeSP& type) : 829 m_clang_ast_type(type->GetClangAST(), type->GetClangFullType()), 830 m_type_sp(type) 831 { 832 } 833 834 void 835 TypeImpl::SetType (const lldb::TypeSP &type_sp) 836 { 837 if (type_sp) 838 { 839 m_clang_ast_type.SetClangType (type_sp->GetClangAST(), type_sp->GetClangFullType()); 840 m_type_sp = type_sp; 841 } 842 else 843 { 844 m_clang_ast_type.Clear(); 845 m_type_sp.reset(); 846 } 847 } 848 849 TypeImpl& 850 TypeImpl::operator = (const TypeImpl& rhs) 851 { 852 if (*this != rhs) 853 { 854 m_clang_ast_type = rhs.m_clang_ast_type; 855 m_type_sp = rhs.m_type_sp; 856 } 857 return *this; 858 } 859 860 clang::ASTContext* 861 TypeImpl::GetASTContext() 862 { 863 if (!IsValid()) 864 return NULL; 865 866 return m_clang_ast_type.GetASTContext(); 867 } 868 869 lldb::clang_type_t 870 TypeImpl::GetOpaqueQualType() 871 { 872 if (!IsValid()) 873 return NULL; 874 875 return m_clang_ast_type.GetOpaqueQualType(); 876 } 877 878 bool 879 TypeImpl::GetDescription (lldb_private::Stream &strm, 880 lldb::DescriptionLevel description_level) 881 { 882 if (m_clang_ast_type.IsValid()) 883 { 884 ClangASTType::DumpTypeDescription (m_clang_ast_type.GetASTContext(), 885 m_clang_ast_type.GetOpaqueQualType(), 886 &strm); 887 } 888 else 889 { 890 strm.PutCString ("No value"); 891 } 892 return true; 893 } 894 895