contrib/llvm/tools/lldb/source/Symbol/Type.cpp

   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 #include "llvm/ADT/StringRef.h"
  32
  33 #include "clang/AST/Decl.h"
  34 #include "clang/AST/DeclObjC.h"
  35
  36 using namespace lldb;
  37 using namespace lldb_private;
  38
  39 class TypeAppendVisitor
  40 {
  41 public:
  42     TypeAppendVisitor(TypeListImpl &type_list) :
  43         m_type_list(type_list)
  44     {
  45     }
  46
  47     bool
  48     operator() (const lldb::TypeSP& type)
  49     {
  50         m_type_list.Append(TypeImplSP(new TypeImpl(type)));
  51         return true;
  52     }
  53
  54 private:
  55     TypeListImpl &m_type_list;
  56 };
  57
  58 void
  59 TypeListImpl::Append (const lldb_private::TypeList &type_list)
  60 {
  61     TypeAppendVisitor cb(*this);
  62     type_list.ForEach(cb);
  63 }
  64
  65
  66 Type *
  67 SymbolFileType::GetType ()
  68 {
  69     if (!m_type_sp)
  70     {
  71         Type *resolved_type = m_symbol_file.ResolveTypeUID (GetID());
  72         if (resolved_type)
  73             m_type_sp = resolved_type->shared_from_this();
  74     }
  75     return m_type_sp.get();
  76 }
  77
  78
  79 Type::Type
  80 (
  81     lldb::user_id_t uid,
  82     SymbolFile* symbol_file,
  83     const ConstString &name,
  84     uint64_t byte_size,
  85     SymbolContextScope *context,
  86     user_id_t encoding_uid,
  87     EncodingDataType encoding_uid_type,
  88     const Declaration& decl,
  89     const ClangASTType &clang_type,
  90     ResolveState clang_type_resolve_state
  91 ) :
  92     std::enable_shared_from_this<Type> (),
  93     UserID (uid),
  94     m_name (name),
  95     m_symbol_file (symbol_file),
  96     m_context (context),
  97     m_encoding_type (nullptr),
  98     m_encoding_uid (encoding_uid),
  99     m_encoding_uid_type (encoding_uid_type),
 100     m_byte_size (byte_size),
 101     m_decl (decl),
 102     m_clang_type (clang_type)
 103 {
 104     m_flags.clang_type_resolve_state = (clang_type ? clang_type_resolve_state : eResolveStateUnresolved);
 105     m_flags.is_complete_objc_class = false;
 106 }
 107
 108 Type::Type () :
 109     std::enable_shared_from_this<Type> (),
 110     UserID (0),
 111     m_name ("<INVALID TYPE>"),
 112     m_symbol_file (nullptr),
 113     m_context (nullptr),
 114     m_encoding_type (nullptr),
 115     m_encoding_uid (LLDB_INVALID_UID),
 116     m_encoding_uid_type (eEncodingInvalid),
 117     m_byte_size (0),
 118     m_decl (),
 119     m_clang_type ()
 120 {
 121     m_flags.clang_type_resolve_state = eResolveStateUnresolved;
 122     m_flags.is_complete_objc_class = false;
 123 }
 124
 125
 126 Type::Type (const Type &rhs) :
 127     std::enable_shared_from_this<Type> (rhs),
 128     UserID (rhs),
 129     m_name (rhs.m_name),
 130     m_symbol_file (rhs.m_symbol_file),
 131     m_context (rhs.m_context),
 132     m_encoding_type (rhs.m_encoding_type),
 133     m_encoding_uid (rhs.m_encoding_uid),
 134     m_encoding_uid_type (rhs.m_encoding_uid_type),
 135     m_byte_size (rhs.m_byte_size),
 136     m_decl (rhs.m_decl),
 137     m_clang_type (rhs.m_clang_type),
 138     m_flags (rhs.m_flags)
 139 {
 140 }
 141
 142 const Type&
 143 Type::operator= (const Type& rhs)
 144 {
 145     if (this != &rhs)
 146     {
 147     }
 148     return *this;
 149 }
 150
 151
 152 void
 153 Type::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name)
 154 {
 155     *s << "id = " << (const UserID&)*this;
 156
 157     // Call the name accessor to make sure we resolve the type name
 158     if (show_name)
 159     {
 160         const ConstString &type_name = GetName();
 161         if (type_name)
 162         {
 163             *s << ", name = \"" << type_name << '"';
 164             ConstString qualified_type_name (GetQualifiedName());
 165             if (qualified_type_name != type_name)
 166             {
 167                 *s << ", qualified = \"" << qualified_type_name << '"';
 168             }
 169         }
 170     }
 171
 172     // Call the get byte size accesor so we resolve our byte size
 173     if (GetByteSize())
 174         s->Printf(", byte-size = %" PRIu64, m_byte_size);
 175     bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose);
 176     m_decl.Dump(s, show_fullpaths);
 177
 178     if (m_clang_type.IsValid())
 179     {
 180         *s << ", clang_type = \"";
 181         GetClangForwardType().DumpTypeDescription(s);
 182         *s << '"';
 183     }
 184     else if (m_encoding_uid != LLDB_INVALID_UID)
 185     {
 186         s->Printf(", type_uid = 0x%8.8" PRIx64, m_encoding_uid);
 187         switch (m_encoding_uid_type)
 188         {
 189         case eEncodingInvalid: break;
 190         case eEncodingIsUID: s->PutCString(" (unresolved type)"); break;
 191         case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break;
 192         case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break;
 193         case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break;
 194         case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break;
 195         case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break;
 196         case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break;
 197         case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break;
 198         case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break;
 199         }
 200     }
 201 }
 202
 203
 204 void
 205 Type::Dump (Stream *s, bool show_context)
 206 {
 207     s->Printf("%p: ", static_cast<void*>(this));
 208     s->Indent();
 209     *s << "Type" << static_cast<const UserID&>(*this) << ' ';
 210     if (m_name)
 211         *s << ", name = \"" << m_name << "\"";
 212
 213     if (m_byte_size != 0)
 214         s->Printf(", size = %" PRIu64, m_byte_size);
 215
 216     if (show_context && m_context != nullptr)
 217     {
 218         s->PutCString(", context = ( ");
 219         m_context->DumpSymbolContext(s);
 220         s->PutCString(" )");
 221     }
 222
 223     bool show_fullpaths = false;
 224     m_decl.Dump (s,show_fullpaths);
 225
 226     if (m_clang_type.IsValid())
 227     {
 228         *s << ", clang_type = " << m_clang_type.GetOpaqueQualType() << ' ';
 229         GetClangForwardType().DumpTypeDescription (s);
 230     }
 231     else if (m_encoding_uid != LLDB_INVALID_UID)
 232     {
 233         *s << ", type_data = " << (uint64_t)m_encoding_uid;
 234         switch (m_encoding_uid_type)
 235         {
 236         case eEncodingInvalid: break;
 237         case eEncodingIsUID: s->PutCString(" (unresolved type)"); break;
 238         case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break;
 239         case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break;
 240         case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break;
 241         case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break;
 242         case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break;
 243         case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break;
 244         case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break;
 245         case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break;
 246         }
 247     }
 248
 249 //
 250 //  if (m_access)
 251 //      s->Printf(", access = %u", m_access);
 252     s->EOL();
 253 }
 254
 255 const ConstString &
 256 Type::GetName()
 257 {
 258     if (!m_name)
 259         m_name = GetClangForwardType().GetConstTypeName();
 260     return m_name;
 261 }
 262
 263 void
 264 Type::DumpTypeName(Stream *s)
 265 {
 266     GetName().Dump(s, "<invalid-type-name>");
 267 }
 268
 269
 270 void
 271 Type::DumpValue
 272 (
 273     ExecutionContext *exe_ctx,
 274     Stream *s,
 275     const DataExtractor &data,
 276     uint32_t data_byte_offset,
 277     bool show_types,
 278     bool show_summary,
 279     bool verbose,
 280     lldb::Format format
 281 )
 282 {
 283     if (ResolveClangType(eResolveStateForward))
 284     {
 285         if (show_types)
 286         {
 287             s->PutChar('(');
 288             if (verbose)
 289                 s->Printf("Type{0x%8.8" PRIx64 "} ", GetID());
 290             DumpTypeName (s);
 291             s->PutCString(") ");
 292         }
 293
 294         GetClangForwardType().DumpValue (exe_ctx,
 295                                          s,
 296                                          format == lldb::eFormatDefault ? GetFormat() : format,
 297                                          data,
 298                                          data_byte_offset,
 299                                          GetByteSize(),
 300                                          0, // Bitfield bit size
 301                                          0, // Bitfield bit offset
 302                                          show_types,
 303                                          show_summary,
 304                                          verbose,
 305                                          0);
 306     }
 307 }
 308
 309 Type *
 310 Type::GetEncodingType ()
 311 {
 312     if (m_encoding_type == nullptr && m_encoding_uid != LLDB_INVALID_UID)
 313         m_encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
 314     return m_encoding_type;
 315 }
 316
 317
 318
 319 uint64_t
 320 Type::GetByteSize()
 321 {
 322     if (m_byte_size == 0)
 323     {
 324         switch (m_encoding_uid_type)
 325         {
 326         case eEncodingInvalid:
 327         case eEncodingIsSyntheticUID:
 328             break;
 329         case eEncodingIsUID:
 330         case eEncodingIsConstUID:
 331         case eEncodingIsRestrictUID:
 332         case eEncodingIsVolatileUID:
 333         case eEncodingIsTypedefUID:
 334             {
 335                 Type *encoding_type = GetEncodingType ();
 336                 if (encoding_type)
 337                     m_byte_size = encoding_type->GetByteSize();
 338                 if (m_byte_size == 0)
 339                     m_byte_size = GetClangLayoutType().GetByteSize();
 340             }
 341             break;
 342
 343         // If we are a pointer or reference, then this is just a pointer size;
 344         case eEncodingIsPointerUID:
 345         case eEncodingIsLValueReferenceUID:
 346         case eEncodingIsRValueReferenceUID:
 347             m_byte_size = m_symbol_file->GetClangASTContext().GetPointerByteSize();
 348             break;
 349         }
 350     }
 351     return m_byte_size;
 352 }
 353
 354
 355 uint32_t
 356 Type::GetNumChildren (bool omit_empty_base_classes)
 357 {
 358     return GetClangForwardType().GetNumChildren(omit_empty_base_classes);
 359 }
 360
 361 bool
 362 Type::IsAggregateType ()
 363 {
 364     return GetClangForwardType().IsAggregateType();
 365 }
 366
 367 lldb::TypeSP
 368 Type::GetTypedefType()
 369 {
 370     lldb::TypeSP type_sp;
 371     if (IsTypedef())
 372     {
 373         Type *typedef_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
 374         if (typedef_type)
 375             type_sp = typedef_type->shared_from_this();
 376     }
 377     return type_sp;
 378 }
 379
 380
 381
 382 lldb::Format
 383 Type::GetFormat ()
 384 {
 385     return GetClangForwardType().GetFormat();
 386 }
 387
 388
 389
 390 lldb::Encoding
 391 Type::GetEncoding (uint64_t &count)
 392 {
 393     // Make sure we resolve our type if it already hasn't been.
 394     return GetClangForwardType().GetEncoding(count);
 395 }
 396
 397 bool
 398 Type::DumpValueInMemory
 399 (
 400     ExecutionContext *exe_ctx,
 401     Stream *s,
 402     lldb::addr_t address,
 403     AddressType address_type,
 404     bool show_types,
 405     bool show_summary,
 406     bool verbose
 407 )
 408 {
 409     if (address != LLDB_INVALID_ADDRESS)
 410     {
 411         DataExtractor data;
 412         Target *target = nullptr;
 413         if (exe_ctx)
 414             target = exe_ctx->GetTargetPtr();
 415         if (target)
 416             data.SetByteOrder (target->GetArchitecture().GetByteOrder());
 417         if (ReadFromMemory (exe_ctx, address, address_type, data))
 418         {
 419             DumpValue(exe_ctx, s, data, 0, show_types, show_summary, verbose);
 420             return true;
 421         }
 422     }
 423     return false;
 424 }
 425
 426
 427 bool
 428 Type::ReadFromMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data)
 429 {
 430     if (address_type == eAddressTypeFile)
 431     {
 432         // Can't convert a file address to anything valid without more
 433         // context (which Module it came from)
 434         return false;
 435     }
 436
 437     const uint64_t byte_size = GetByteSize();
 438     if (data.GetByteSize() < byte_size)
 439     {
 440         lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));
 441         data.SetData(data_sp);
 442     }
 443
 444     uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size);
 445     if (dst != nullptr)
 446     {
 447         if (address_type == eAddressTypeHost)
 448         {
 449             // The address is an address in this process, so just copy it
 450             if (addr == 0)
 451                 return false;
 452             memcpy (dst, (uint8_t*)nullptr + addr, byte_size);
 453             return true;
 454         }
 455         else
 456         {
 457             if (exe_ctx)
 458             {
 459                 Process *process = exe_ctx->GetProcessPtr();
 460                 if (process)
 461                 {
 462                     Error error;
 463                     return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size, error) == byte_size;
 464                 }
 465             }
 466         }
 467     }
 468     return false;
 469 }
 470
 471
 472 bool
 473 Type::WriteToMemory (ExecutionContext *exe_ctx, lldb::addr_t addr, AddressType address_type, DataExtractor &data)
 474 {
 475     return false;
 476 }
 477
 478
 479 TypeList*
 480 Type::GetTypeList()
 481 {
 482     return GetSymbolFile()->GetTypeList();
 483 }
 484
 485 const Declaration &
 486 Type::GetDeclaration () const
 487 {
 488     return m_decl;
 489 }
 490
 491 bool
 492 Type::ResolveClangType (ResolveState clang_type_resolve_state)
 493 {
 494     Type *encoding_type = nullptr;
 495     if (!m_clang_type.IsValid())
 496     {
 497         encoding_type = GetEncodingType();
 498         if (encoding_type)
 499         {
 500             switch (m_encoding_uid_type)
 501             {
 502             case eEncodingIsUID:
 503                 {
 504                     ClangASTType encoding_clang_type = encoding_type->GetClangForwardType();
 505                     if (encoding_clang_type.IsValid())
 506                     {
 507                         m_clang_type = encoding_clang_type;
 508                         m_flags.clang_type_resolve_state = encoding_type->m_flags.clang_type_resolve_state;
 509                     }
 510                 }
 511                 break;
 512
 513             case eEncodingIsConstUID:
 514                 m_clang_type = encoding_type->GetClangForwardType().AddConstModifier();
 515                 break;
 516
 517             case eEncodingIsRestrictUID:
 518                 m_clang_type = encoding_type->GetClangForwardType().AddRestrictModifier();
 519                 break;
 520
 521             case eEncodingIsVolatileUID:
 522                 m_clang_type = encoding_type->GetClangForwardType().AddVolatileModifier();
 523                 break;
 524
 525             case eEncodingIsTypedefUID:
 526                 m_clang_type = encoding_type->GetClangForwardType().CreateTypedefType (GetName().AsCString(),
 527                                                                                        GetSymbolFile()->GetClangDeclContextContainingTypeUID(GetID()));
 528                 m_name.Clear();
 529                 break;
 530
 531             case eEncodingIsPointerUID:
 532                 m_clang_type = encoding_type->GetClangForwardType().GetPointerType();
 533                 break;
 534
 535             case eEncodingIsLValueReferenceUID:
 536                 m_clang_type = encoding_type->GetClangForwardType().GetLValueReferenceType();
 537                 break;
 538
 539             case eEncodingIsRValueReferenceUID:
 540                 m_clang_type = encoding_type->GetClangForwardType().GetRValueReferenceType();
 541                 break;
 542
 543             default:
 544                 assert(!"Unhandled encoding_data_type.");
 545                 break;
 546             }
 547         }
 548         else
 549         {
 550             // We have no encoding type, return void?
 551             ClangASTType void_clang_type (ClangASTContext::GetBasicType(GetClangASTContext().getASTContext(), eBasicTypeVoid));
 552             switch (m_encoding_uid_type)
 553             {
 554             case eEncodingIsUID:
 555                 m_clang_type = void_clang_type;
 556                 break;
 557
 558             case eEncodingIsConstUID:
 559                 m_clang_type = void_clang_type.AddConstModifier ();
 560                 break;
 561
 562             case eEncodingIsRestrictUID:
 563                 m_clang_type = void_clang_type.AddRestrictModifier ();
 564                 break;
 565
 566             case eEncodingIsVolatileUID:
 567                 m_clang_type = void_clang_type.AddVolatileModifier ();
 568                 break;
 569
 570             case eEncodingIsTypedefUID:
 571                 m_clang_type = void_clang_type.CreateTypedefType (GetName().AsCString(),
 572                                                                   GetSymbolFile()->GetClangDeclContextContainingTypeUID(GetID()));
 573                 break;
 574
 575             case eEncodingIsPointerUID:
 576                 m_clang_type = void_clang_type.GetPointerType ();
 577                 break;
 578
 579             case eEncodingIsLValueReferenceUID:
 580                 m_clang_type = void_clang_type.GetLValueReferenceType ();
 581                 break;
 582
 583             case eEncodingIsRValueReferenceUID:
 584                 m_clang_type = void_clang_type.GetRValueReferenceType ();
 585                 break;
 586
 587             default:
 588                 assert(!"Unhandled encoding_data_type.");
 589                 break;
 590             }
 591         }
 592     }
 593
 594     // Check if we have a forward reference to a class/struct/union/enum?
 595     if (m_clang_type.IsValid() && m_flags.clang_type_resolve_state < clang_type_resolve_state)
 596     {
 597         m_flags.clang_type_resolve_state = eResolveStateFull;
 598         if (!m_clang_type.IsDefined ())
 599         {
 600             // We have a forward declaration, we need to resolve it to a complete definition.
 601             m_symbol_file->ResolveClangOpaqueTypeDefinition (m_clang_type);
 602         }
 603     }
 604
 605     // If we have an encoding type, then we need to make sure it is
 606     // resolved appropriately.
 607     if (m_encoding_uid != LLDB_INVALID_UID)
 608     {
 609         if (encoding_type == nullptr)
 610             encoding_type = GetEncodingType();
 611         if (encoding_type)
 612         {
 613             ResolveState encoding_clang_type_resolve_state = clang_type_resolve_state;
 614
 615             if (clang_type_resolve_state == eResolveStateLayout)
 616             {
 617                 switch (m_encoding_uid_type)
 618                 {
 619                 case eEncodingIsPointerUID:
 620                 case eEncodingIsLValueReferenceUID:
 621                 case eEncodingIsRValueReferenceUID:
 622                     encoding_clang_type_resolve_state = eResolveStateForward;
 623                     break;
 624                 default:
 625                     break;
 626                 }
 627             }
 628             encoding_type->ResolveClangType (encoding_clang_type_resolve_state);
 629         }
 630     }
 631     return m_clang_type.IsValid();
 632 }
 633 uint32_t
 634 Type::GetEncodingMask ()
 635 {
 636     uint32_t encoding_mask = 1u << m_encoding_uid_type;
 637     Type *encoding_type = GetEncodingType();
 638     assert (encoding_type != this);
 639     if (encoding_type)
 640         encoding_mask |= encoding_type->GetEncodingMask ();
 641     return encoding_mask;
 642 }
 643
 644 ClangASTType
 645 Type::GetClangFullType ()
 646 {
 647     ResolveClangType(eResolveStateFull);
 648     return m_clang_type;
 649 }
 650
 651 ClangASTType
 652 Type::GetClangLayoutType ()
 653 {
 654     ResolveClangType(eResolveStateLayout);
 655     return m_clang_type;
 656 }
 657
 658 ClangASTType
 659 Type::GetClangForwardType ()
 660 {
 661     ResolveClangType (eResolveStateForward);
 662     return m_clang_type;
 663 }
 664
 665 ClangASTContext &
 666 Type::GetClangASTContext ()
 667 {
 668     return m_symbol_file->GetClangASTContext();
 669 }
 670
 671 int
 672 Type::Compare(const Type &a, const Type &b)
 673 {
 674     // Just compare the UID values for now...
 675     lldb::user_id_t a_uid = a.GetID();
 676     lldb::user_id_t b_uid = b.GetID();
 677     if (a_uid < b_uid)
 678         return -1;
 679     if (a_uid > b_uid)
 680         return 1;
 681     return 0;
 682 //  if (a.getQualType() == b.getQualType())
 683 //      return 0;
 684 }
 685
 686
 687 #if 0  // START REMOVE
 688 // Move this into ClangASTType
 689 void *
 690 Type::CreateClangPointerType (Type *type)
 691 {
 692     assert(type);
 693     return GetClangASTContext().CreatePointerType(type->GetClangForwardType());
 694 }
 695
 696 void *
 697 Type::CreateClangTypedefType (Type *typedef_type, Type *base_type)
 698 {
 699     assert(typedef_type && base_type);
 700     return GetClangASTContext().CreateTypedefType (typedef_type->GetName().AsCString(),
 701                                                    base_type->GetClangForwardType(),
 702                                                    typedef_type->GetSymbolFile()->GetClangDeclContextContainingTypeUID(typedef_type->GetID()));
 703 }
 704
 705 void *
 706 Type::CreateClangLValueReferenceType (Type *type)
 707 {
 708     assert(type);
 709     return GetClangASTContext().CreateLValueReferenceType(type->GetClangForwardType());
 710 }
 711
 712 void *
 713 Type::CreateClangRValueReferenceType (Type *type)
 714 {
 715     assert(type);
 716     return GetClangASTContext().CreateRValueReferenceType (type->GetClangForwardType());
 717 }
 718 #endif // END REMOVE
 719
 720 bool
 721 Type::IsRealObjCClass()
 722 {
 723     // For now we are just skipping ObjC classes that get made by hand from the runtime, because
 724     // those don't have any information.  We could extend this to only return true for "full
 725     // definitions" if we can figure that out.
 726
 727     if (m_clang_type.IsObjCObjectOrInterfaceType() && GetByteSize() != 0)
 728         return true;
 729     else
 730         return false;
 731 }
 732
 733 ConstString
 734 Type::GetQualifiedName ()
 735 {
 736     return GetClangForwardType().GetConstTypeName();
 737 }
 738
 739
 740 bool
 741 Type::GetTypeScopeAndBasename (const char* &name_cstr,
 742                                std::string &scope,
 743                                std::string &basename,
 744                                TypeClass &type_class)
 745 {
 746     // Protect against null c string.
 747
 748     type_class = eTypeClassAny;
 749
 750     if (name_cstr && name_cstr[0])
 751     {
 752         llvm::StringRef name_strref(name_cstr);
 753         if (name_strref.startswith("struct "))
 754         {
 755             name_cstr += 7;
 756             type_class = eTypeClassStruct;
 757         }
 758         else if (name_strref.startswith("class "))
 759         {
 760             name_cstr += 6;
 761             type_class = eTypeClassClass;
 762         }
 763         else if (name_strref.startswith("union "))
 764         {
 765             name_cstr += 6;
 766             type_class = eTypeClassUnion;
 767         }
 768         else if (name_strref.startswith("enum "))
 769         {
 770             name_cstr += 5;
 771             type_class = eTypeClassEnumeration;
 772         }
 773         else if (name_strref.startswith("typedef "))
 774         {
 775             name_cstr += 8;
 776             type_class = eTypeClassTypedef;
 777         }
 778         const char *basename_cstr = name_cstr;
 779         const char* namespace_separator = ::strstr (basename_cstr, "::");
 780         if (namespace_separator)
 781         {
 782             const char* template_arg_char = ::strchr (basename_cstr, '<');
 783             while (namespace_separator != nullptr)
 784             {
 785                 if (template_arg_char && namespace_separator > template_arg_char) // but namespace'd template arguments are still good to go
 786                     break;
 787                 basename_cstr = namespace_separator + 2;
 788                 namespace_separator = strstr(basename_cstr, "::");
 789             }
 790             if (basename_cstr > name_cstr)
 791             {
 792                 scope.assign (name_cstr, basename_cstr - name_cstr);
 793                 basename.assign (basename_cstr);
 794                 return true;
 795             }
 796         }
 797     }
 798     return false;
 799 }
 800
 801
 802 ModuleSP
 803 Type::GetModule()
 804 {
 805     if (m_symbol_file)
 806         return m_symbol_file->GetObjectFile()->GetModule();
 807     return ModuleSP();
 808 }
 809
 810
 811 TypeAndOrName::TypeAndOrName () : m_type_pair(), m_type_name()
 812 {
 813
 814 }
 815
 816 TypeAndOrName::TypeAndOrName (TypeSP &in_type_sp) : m_type_pair(in_type_sp)
 817 {
 818     if (in_type_sp)
 819         m_type_name = in_type_sp->GetName();
 820 }
 821
 822 TypeAndOrName::TypeAndOrName (const char *in_type_str) : m_type_name(in_type_str)
 823 {
 824 }
 825
 826 TypeAndOrName::TypeAndOrName (const TypeAndOrName &rhs) : m_type_pair (rhs.m_type_pair), m_type_name (rhs.m_type_name)
 827 {
 828
 829 }
 830
 831 TypeAndOrName::TypeAndOrName (ConstString &in_type_const_string) : m_type_name (in_type_const_string)
 832 {
 833 }
 834
 835 TypeAndOrName &
 836 TypeAndOrName::operator= (const TypeAndOrName &rhs)
 837 {
 838     if (this != &rhs)
 839     {
 840         m_type_name = rhs.m_type_name;
 841         m_type_pair = rhs.m_type_pair;
 842     }
 843     return *this;
 844 }
 845
 846 bool
 847 TypeAndOrName::operator==(const TypeAndOrName &other) const
 848 {
 849     if (m_type_pair != other.m_type_pair)
 850         return false;
 851     if (m_type_name != other.m_type_name)
 852         return false;
 853     return true;
 854 }
 855
 856 bool
 857 TypeAndOrName::operator!=(const TypeAndOrName &other) const
 858 {
 859     if (m_type_pair != other.m_type_pair)
 860         return true;
 861     if (m_type_name != other.m_type_name)
 862         return true;
 863     return false;
 864 }
 865
 866 ConstString
 867 TypeAndOrName::GetName () const
 868 {
 869     if (m_type_name)
 870         return m_type_name;
 871     if (m_type_pair)
 872         return m_type_pair.GetName();
 873     return ConstString("<invalid>");
 874 }
 875
 876 void
 877 TypeAndOrName::SetName (const ConstString &type_name)
 878 {
 879     m_type_name = type_name;
 880 }
 881
 882 void
 883 TypeAndOrName::SetName (const char *type_name_cstr)
 884 {
 885     m_type_name.SetCString (type_name_cstr);
 886 }
 887
 888 void
 889 TypeAndOrName::SetTypeSP (lldb::TypeSP type_sp)
 890 {
 891     m_type_pair.SetType(type_sp);
 892     if (m_type_pair)
 893         m_type_name = m_type_pair.GetName();
 894 }
 895
 896 void
 897 TypeAndOrName::SetClangASTType (ClangASTType clang_type)
 898 {
 899     m_type_pair.SetType(clang_type);
 900     if (m_type_pair)
 901         m_type_name = m_type_pair.GetName();
 902 }
 903
 904 bool
 905 TypeAndOrName::IsEmpty()  const
 906 {
 907     if ((bool)m_type_name || (bool)m_type_pair)
 908         return false;
 909     else
 910         return true;
 911 }
 912
 913 void
 914 TypeAndOrName::Clear ()
 915 {
 916     m_type_name.Clear();
 917     m_type_pair.Clear();
 918 }
 919
 920 bool
 921 TypeAndOrName::HasName () const
 922 {
 923     return (bool)m_type_name;
 924 }
 925
 926 bool
 927 TypeAndOrName::HasTypeSP () const
 928 {
 929     return m_type_pair.GetTypeSP().get() != nullptr;
 930 }
 931
 932 bool
 933 TypeAndOrName::HasClangASTType () const
 934 {
 935     return m_type_pair.GetClangASTType().IsValid();
 936 }
 937
 938
 939 TypeImpl::TypeImpl() :
 940     m_module_wp(),
 941     m_static_type(),
 942     m_dynamic_type()
 943 {
 944 }
 945
 946 TypeImpl::TypeImpl(const TypeImpl& rhs) :
 947     m_module_wp (rhs.m_module_wp),
 948     m_static_type(rhs.m_static_type),
 949     m_dynamic_type(rhs.m_dynamic_type)
 950 {
 951 }
 952
 953 TypeImpl::TypeImpl (const lldb::TypeSP &type_sp) :
 954     m_module_wp (),
 955     m_static_type(),
 956     m_dynamic_type()
 957 {
 958     SetType (type_sp);
 959 }
 960
 961 TypeImpl::TypeImpl (const ClangASTType &clang_type) :
 962     m_module_wp (),
 963     m_static_type(),
 964     m_dynamic_type()
 965 {
 966     SetType (clang_type);
 967 }
 968
 969 TypeImpl::TypeImpl (const lldb::TypeSP &type_sp, const ClangASTType &dynamic) :
 970     m_module_wp (),
 971     m_static_type (type_sp),
 972     m_dynamic_type(dynamic)
 973 {
 974     SetType (type_sp, dynamic);
 975 }
 976
 977 TypeImpl::TypeImpl (const ClangASTType &static_type, const ClangASTType &dynamic_type) :
 978     m_module_wp (),
 979     m_static_type (),
 980     m_dynamic_type()
 981 {
 982     SetType (static_type, dynamic_type);
 983 }
 984
 985 TypeImpl::TypeImpl (const TypePair &pair, const ClangASTType &dynamic) :
 986     m_module_wp (),
 987     m_static_type (),
 988     m_dynamic_type()
 989 {
 990     SetType (pair, dynamic);
 991 }
 992
 993 void
 994 TypeImpl::SetType (const lldb::TypeSP &type_sp)
 995 {
 996     m_static_type.SetType(type_sp);
 997     if (type_sp)
 998         m_module_wp = type_sp->GetModule();
 999     else
1000         m_module_wp = lldb::ModuleWP();
1001 }
1002
1003 void
1004 TypeImpl::SetType (const ClangASTType &clang_type)
1005 {
1006     m_module_wp = lldb::ModuleWP();
1007     m_static_type.SetType (clang_type);
1008 }
1009
1010 void
1011 TypeImpl::SetType (const lldb::TypeSP &type_sp, const ClangASTType &dynamic)
1012 {
1013     SetType (type_sp);
1014     m_dynamic_type = dynamic;
1015 }
1016
1017 void
1018 TypeImpl::SetType (const ClangASTType &clang_type, const ClangASTType &dynamic)
1019 {
1020     m_module_wp = lldb::ModuleWP();
1021     m_static_type.SetType (clang_type);
1022     m_dynamic_type = dynamic;
1023 }
1024
1025 void
1026 TypeImpl::SetType (const TypePair &pair, const ClangASTType &dynamic)
1027 {
1028     m_module_wp = pair.GetModule();
1029     m_static_type = pair;
1030     m_dynamic_type = dynamic;
1031 }
1032
1033 TypeImpl&
1034 TypeImpl::operator = (const TypeImpl& rhs)
1035 {
1036     if (rhs != *this)
1037     {
1038         m_module_wp = rhs.m_module_wp;
1039         m_static_type = rhs.m_static_type;
1040         m_dynamic_type = rhs.m_dynamic_type;
1041     }
1042     return *this;
1043 }
1044
1045 bool
1046 TypeImpl::CheckModule (lldb::ModuleSP &module_sp) const
1047 {
1048     // Check if we have a module for this type. If we do and the shared pointer is
1049     // can be successfully initialized with m_module_wp, return true. Else return false
1050     // if we didn't have a module, or if we had a module and it has been deleted. Any
1051     // functions doing anything with a TypeSP in this TypeImpl class should call this
1052     // function and only do anything with the ivars if this function returns true. If
1053     // we have a module, the "module_sp" will be filled in with a strong reference to the
1054     // module so that the module will at least stay around long enough for the type
1055     // query to succeed.
1056     module_sp = m_module_wp.lock();
1057     if (!module_sp)
1058     {
1059         lldb::ModuleWP empty_module_wp;
1060         // If either call to "std::weak_ptr::owner_before(...) value returns true, this
1061         // indicates that m_module_wp once contained (possibly still does) a reference
1062         // to a valid shared pointer. This helps us know if we had a valid reference to
1063         // a section which is now invalid because the module it was in was deleted
1064         if (empty_module_wp.owner_before(m_module_wp) || m_module_wp.owner_before(empty_module_wp))
1065         {
1066             // m_module_wp had a valid reference to a module, but all strong references
1067             // have been released and the module has been deleted
1068             return false;
1069         }
1070     }
1071     // We either successfully locked the module, or didn't have one to begin with
1072     return true;
1073 }
1074
1075 bool
1076 TypeImpl::operator == (const TypeImpl& rhs) const
1077 {
1078     return m_static_type == rhs.m_static_type && m_dynamic_type == rhs.m_dynamic_type;
1079 }
1080
1081 bool
1082 TypeImpl::operator != (const TypeImpl& rhs) const
1083 {
1084     return m_static_type != rhs.m_static_type || m_dynamic_type != rhs.m_dynamic_type;
1085 }
1086
1087 bool
1088 TypeImpl::IsValid() const
1089 {
1090     // just a name is not valid
1091     ModuleSP module_sp;
1092     if (CheckModule (module_sp))
1093         return m_static_type.IsValid() || m_dynamic_type.IsValid();
1094     return false;
1095 }
1096
1097 TypeImpl::operator bool () const
1098 {
1099     return IsValid();
1100 }
1101
1102 void
1103 TypeImpl::Clear()
1104 {
1105     m_module_wp = lldb::ModuleWP();
1106     m_static_type.Clear();
1107     m_dynamic_type.Clear();
1108 }
1109
1110 ConstString
1111 TypeImpl::GetName ()  const
1112 {
1113     ModuleSP module_sp;
1114     if (CheckModule (module_sp))
1115     {
1116         if (m_dynamic_type)
1117             return m_dynamic_type.GetTypeName();
1118         return m_static_type.GetName ();
1119     }
1120     return ConstString();
1121 }
1122
1123 ConstString
1124 TypeImpl::GetDisplayTypeName ()  const
1125 {
1126     ModuleSP module_sp;
1127     if (CheckModule (module_sp))
1128     {
1129         if (m_dynamic_type)
1130             return m_dynamic_type.GetDisplayTypeName();
1131         return m_static_type.GetDisplayTypeName();
1132     }
1133     return ConstString();
1134 }
1135
1136 TypeImpl
1137 TypeImpl::GetPointerType () const
1138 {
1139     ModuleSP module_sp;
1140     if (CheckModule (module_sp))
1141     {
1142         if (m_dynamic_type.IsValid())
1143         {
1144             return TypeImpl(m_static_type, m_dynamic_type.GetPointerType());
1145         }
1146         return TypeImpl(m_static_type.GetPointerType());
1147     }
1148     return TypeImpl();
1149 }
1150
1151 TypeImpl
1152 TypeImpl::GetPointeeType () const
1153 {
1154     ModuleSP module_sp;
1155     if (CheckModule (module_sp))
1156     {
1157         if (m_dynamic_type.IsValid())
1158         {
1159             return TypeImpl(m_static_type, m_dynamic_type.GetPointeeType());
1160         }
1161         return TypeImpl(m_static_type.GetPointeeType());
1162     }
1163     return TypeImpl();
1164 }
1165
1166 TypeImpl
1167 TypeImpl::GetReferenceType () const
1168 {
1169     ModuleSP module_sp;
1170     if (CheckModule (module_sp))
1171     {
1172         if (m_dynamic_type.IsValid())
1173         {
1174             return TypeImpl(m_static_type, m_dynamic_type.GetLValueReferenceType());
1175         }
1176         return TypeImpl(m_static_type.GetReferenceType());
1177     }
1178     return TypeImpl();
1179 }
1180
1181 TypeImpl
1182 TypeImpl::GetTypedefedType () const
1183 {
1184     ModuleSP module_sp;
1185     if (CheckModule (module_sp))
1186     {
1187         if (m_dynamic_type.IsValid())
1188         {
1189             return TypeImpl(m_static_type, m_dynamic_type.GetTypedefedType());
1190         }
1191         return TypeImpl(m_static_type.GetTypedefedType());
1192     }
1193     return TypeImpl();
1194 }
1195
1196 TypeImpl
1197 TypeImpl::GetDereferencedType () const
1198 {
1199     ModuleSP module_sp;
1200     if (CheckModule (module_sp))
1201     {
1202         if (m_dynamic_type.IsValid())
1203         {
1204             return TypeImpl(m_static_type, m_dynamic_type.GetNonReferenceType());
1205         }
1206         return TypeImpl(m_static_type.GetDereferencedType());
1207     }
1208     return TypeImpl();
1209 }
1210
1211 TypeImpl
1212 TypeImpl::GetUnqualifiedType() const
1213 {
1214     ModuleSP module_sp;
1215     if (CheckModule (module_sp))
1216     {
1217         if (m_dynamic_type.IsValid())
1218         {
1219             return TypeImpl(m_static_type, m_dynamic_type.GetFullyUnqualifiedType());
1220         }
1221         return TypeImpl(m_static_type.GetUnqualifiedType());
1222     }
1223     return TypeImpl();
1224 }
1225
1226 TypeImpl
1227 TypeImpl::GetCanonicalType() const
1228 {
1229     ModuleSP module_sp;
1230     if (CheckModule (module_sp))
1231     {
1232         if (m_dynamic_type.IsValid())
1233         {
1234             return TypeImpl(m_static_type, m_dynamic_type.GetCanonicalType());
1235         }
1236         return TypeImpl(m_static_type.GetCanonicalType());
1237     }
1238     return TypeImpl();
1239 }
1240
1241 ClangASTType
1242 TypeImpl::GetClangASTType (bool prefer_dynamic)
1243 {
1244     ModuleSP module_sp;
1245     if (CheckModule (module_sp))
1246     {
1247         if (prefer_dynamic)
1248         {
1249             if (m_dynamic_type.IsValid())
1250                 return m_dynamic_type;
1251         }
1252         return m_static_type.GetClangASTType();
1253     }
1254     return ClangASTType();
1255 }
1256
1257 clang::ASTContext *
1258 TypeImpl::GetClangASTContext (bool prefer_dynamic)
1259 {
1260     ModuleSP module_sp;
1261     if (CheckModule (module_sp))
1262     {
1263         if (prefer_dynamic)
1264         {
1265             if (m_dynamic_type.IsValid())
1266                 return m_dynamic_type.GetASTContext();
1267         }
1268         return m_static_type.GetClangASTContext();
1269     }
1270     return NULL;
1271 }
1272
1273 bool
1274 TypeImpl::GetDescription (lldb_private::Stream &strm,
1275                           lldb::DescriptionLevel description_level)
1276 {
1277     ModuleSP module_sp;
1278     if (CheckModule (module_sp))
1279     {
1280         if (m_dynamic_type.IsValid())
1281         {
1282             strm.Printf("Dynamic:\n");
1283             m_dynamic_type.DumpTypeDescription(&strm);
1284             strm.Printf("\nStatic:\n");
1285         }
1286         m_static_type.GetClangASTType().DumpTypeDescription(&strm);
1287     }
1288     else
1289     {
1290         strm.PutCString("Invalid TypeImpl module for type has been deleted\n");
1291     }
1292     return true;
1293 }
1294
1295 TypeMemberFunctionImpl&
1296 TypeMemberFunctionImpl::operator = (const TypeMemberFunctionImpl& rhs)
1297 {
1298     if (this != &rhs)
1299     {
1300         m_type = rhs.m_type;
1301         m_objc_method_decl = rhs.m_objc_method_decl;
1302         m_name = rhs.m_name;
1303         m_kind = rhs.m_kind;
1304     }
1305     return *this;
1306 }
1307
1308 bool
1309 TypeMemberFunctionImpl::IsValid ()
1310 {
1311     return m_type.IsValid() && m_kind != lldb::eMemberFunctionKindUnknown;
1312 }
1313
1314 ConstString
1315 TypeMemberFunctionImpl::GetName () const
1316 {
1317     return m_name;
1318 }
1319
1320 ClangASTType
1321 TypeMemberFunctionImpl::GetType () const
1322 {
1323     return m_type;
1324 }
1325
1326 lldb::MemberFunctionKind
1327 TypeMemberFunctionImpl::GetKind () const
1328 {
1329     return m_kind;
1330 }
1331
1332 std::string
1333 TypeMemberFunctionImpl::GetPrintableTypeName ()
1334 {
1335     if (m_type)
1336         return m_type.GetTypeName().AsCString("<unknown>");
1337     if (m_objc_method_decl)
1338     {
1339         if (m_objc_method_decl->getClassInterface())
1340         {
1341             return m_objc_method_decl->getClassInterface()->getName();
1342         }
1343     }
1344     return "<unknown>";
1345 }
1346
1347 bool
1348 TypeMemberFunctionImpl::GetDescription (Stream& stream)
1349 {
1350     switch (m_kind) {
1351         case lldb::eMemberFunctionKindUnknown:
1352             return false;
1353         case lldb::eMemberFunctionKindConstructor:
1354             stream.Printf("constructor for %s", GetPrintableTypeName().c_str());
1355             break;
1356         case lldb::eMemberFunctionKindDestructor:
1357             stream.Printf("destructor for %s",  GetPrintableTypeName().c_str());
1358             break;
1359         case lldb::eMemberFunctionKindInstanceMethod:
1360             stream.Printf("instance method %s of type %s",
1361                           m_name.AsCString(),
1362                           GetPrintableTypeName().c_str());
1363             break;
1364         case lldb::eMemberFunctionKindStaticMethod:
1365             stream.Printf("static method %s of type %s",
1366                           m_name.AsCString(),
1367                           GetPrintableTypeName().c_str());
1368             break;
1369     }
1370     return true;
1371 }
1372
1373 ClangASTType
1374 TypeMemberFunctionImpl::GetReturnType () const
1375 {
1376     if (m_type)
1377         return m_type.GetFunctionReturnType();
1378     if (m_objc_method_decl)
1379         return ClangASTType(&m_objc_method_decl->getASTContext(),m_objc_method_decl->getReturnType().getAsOpaquePtr());
1380     return ClangASTType();
1381 }
1382
1383 size_t
1384 TypeMemberFunctionImpl::GetNumArguments () const
1385 {
1386     if (m_type)
1387         return m_type.GetNumberOfFunctionArguments();
1388     if (m_objc_method_decl)
1389         return m_objc_method_decl->param_size();
1390     return 0;
1391 }
1392
1393 ClangASTType
1394 TypeMemberFunctionImpl::GetArgumentAtIndex (size_t idx) const
1395 {
1396     if (m_type)
1397         return m_type.GetFunctionArgumentAtIndex (idx);
1398     if (m_objc_method_decl)
1399     {
1400         if (idx < m_objc_method_decl->param_size())
1401             return ClangASTType(&m_objc_method_decl->getASTContext(), m_objc_method_decl->parameters()[idx]->getOriginalType().getAsOpaquePtr());
1402     }
1403     return ClangASTType();
1404 }
1405
1406 TypeEnumMemberImpl::TypeEnumMemberImpl (const clang::EnumConstantDecl* enum_member_decl,
1407                                         const lldb_private::ClangASTType& integer_type) :
1408     m_integer_type_sp(),
1409     m_name(),
1410     m_value(),
1411     m_valid(false)
1412
1413 {
1414     if (enum_member_decl)
1415     {
1416         m_integer_type_sp.reset(new TypeImpl(integer_type));
1417         m_name = ConstString(enum_member_decl->getNameAsString().c_str());
1418         m_value = enum_member_decl->getInitVal();
1419         m_valid = true;
1420     }
1421 }