contrib/llvm/tools/lldb/include/lldb/Symbol/Type.h

   1 //===-- Type.h --------------------------------------------------*- 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 #ifndef liblldb_Type_h_
  11 #define liblldb_Type_h_
  12
  13 #include "lldb/lldb-private.h"
  14 #include "lldb/Core/ClangForward.h"
  15 #include "lldb/Core/ConstString.h"
  16 #include "lldb/Core/UserID.h"
  17 #include "lldb/Symbol/ClangASTType.h"
  18 #include "lldb/Symbol/Declaration.h"
  19
  20 #include <set>
  21
  22 namespace lldb_private {
  23
  24 class SymbolFileType :
  25     public std::enable_shared_from_this<SymbolFileType>,
  26     public UserID
  27     {
  28     public:
  29         SymbolFileType (SymbolFile &symbol_file, lldb::user_id_t uid) :
  30             UserID (uid),
  31             m_symbol_file (symbol_file)
  32         {
  33         }
  34
  35         ~SymbolFileType ()
  36         {
  37         }
  38
  39         Type *
  40         operator->()
  41         {
  42             return GetType ();
  43         }
  44
  45         Type *
  46         GetType ();
  47
  48     protected:
  49         SymbolFile &m_symbol_file;
  50         lldb::TypeSP m_type_sp;
  51     };
  52
  53 class Type :
  54     public std::enable_shared_from_this<Type>,
  55     public UserID
  56 {
  57 public:
  58     typedef enum EncodingDataTypeTag
  59     {
  60         eEncodingInvalid,
  61         eEncodingIsUID,                 ///< This type is the type whose UID is m_encoding_uid
  62         eEncodingIsConstUID,            ///< This type is the type whose UID is m_encoding_uid with the const qualifier added
  63         eEncodingIsRestrictUID,         ///< This type is the type whose UID is m_encoding_uid with the restrict qualifier added
  64         eEncodingIsVolatileUID,         ///< This type is the type whose UID is m_encoding_uid with the volatile qualifier added
  65         eEncodingIsTypedefUID,          ///< This type is pointer to a type whose UID is m_encoding_uid
  66         eEncodingIsPointerUID,          ///< This type is pointer to a type whose UID is m_encoding_uid
  67         eEncodingIsLValueReferenceUID,  ///< This type is L value reference to a type whose UID is m_encoding_uid
  68         eEncodingIsRValueReferenceUID,  ///< This type is R value reference to a type whose UID is m_encoding_uid
  69         eEncodingIsSyntheticUID
  70     } EncodingDataType;
  71
  72     typedef enum ResolveStateTag
  73     {
  74         eResolveStateUnresolved = 0,
  75         eResolveStateForward    = 1,
  76         eResolveStateLayout     = 2,
  77         eResolveStateFull       = 3
  78     } ResolveState;
  79
  80     Type (lldb::user_id_t uid,
  81           SymbolFile* symbol_file,
  82           const ConstString &name,
  83           uint64_t byte_size,
  84           SymbolContextScope *context,
  85           lldb::user_id_t encoding_uid,
  86           EncodingDataType encoding_uid_type,
  87           const Declaration& decl,
  88           const ClangASTType &clang_qual_type,
  89           ResolveState clang_type_resolve_state);
  90
  91     // This makes an invalid type.  Used for functions that return a Type when they
  92     // get an error.
  93     Type();
  94
  95     Type (const Type &rhs);
  96
  97     const Type&
  98     operator= (const Type& rhs);
  99
 100     void
 101     Dump(Stream *s, bool show_context);
 102
 103     void
 104     DumpTypeName(Stream *s);
 105
 106
 107     void
 108     GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name);
 109
 110     SymbolFile *
 111     GetSymbolFile()
 112     {
 113         return m_symbol_file;
 114     }
 115     const SymbolFile *
 116     GetSymbolFile() const
 117     {
 118         return m_symbol_file;
 119     }
 120
 121     TypeList*
 122     GetTypeList();
 123
 124     const ConstString&
 125     GetName();
 126
 127     uint64_t
 128     GetByteSize();
 129
 130     uint32_t
 131     GetNumChildren (bool omit_empty_base_classes);
 132
 133     bool
 134     IsAggregateType ();
 135
 136     bool
 137     IsValidType ()
 138     {
 139         return m_encoding_uid_type != eEncodingInvalid;
 140     }
 141
 142     bool
 143     IsTypedef ()
 144     {
 145         return m_encoding_uid_type == eEncodingIsTypedefUID;
 146     }
 147
 148     lldb::TypeSP
 149     GetTypedefType();
 150
 151     const ConstString &
 152     GetName () const
 153     {
 154         return m_name;
 155     }
 156
 157     ConstString
 158     GetQualifiedName ();
 159
 160     void
 161     DumpValue(ExecutionContext *exe_ctx,
 162               Stream *s,
 163               const DataExtractor &data,
 164               uint32_t data_offset,
 165               bool show_type,
 166               bool show_summary,
 167               bool verbose,
 168               lldb::Format format = lldb::eFormatDefault);
 169
 170     bool
 171     DumpValueInMemory(ExecutionContext *exe_ctx,
 172                       Stream *s,
 173                       lldb::addr_t address,
 174                       AddressType address_type,
 175                       bool show_types,
 176                       bool show_summary,
 177                       bool verbose);
 178
 179     bool
 180     ReadFromMemory (ExecutionContext *exe_ctx,
 181                     lldb::addr_t address,
 182                     AddressType address_type,
 183                     DataExtractor &data);
 184
 185     bool
 186     WriteToMemory (ExecutionContext *exe_ctx,
 187                    lldb::addr_t address,
 188                    AddressType address_type,
 189                    DataExtractor &data);
 190
 191     bool
 192     GetIsDeclaration() const;
 193
 194     void
 195     SetIsDeclaration(bool b);
 196
 197     bool
 198     GetIsExternal() const;
 199
 200     void
 201     SetIsExternal(bool b);
 202
 203     lldb::Format
 204     GetFormat ();
 205
 206     lldb::Encoding
 207     GetEncoding (uint64_t &count);
 208
 209     SymbolContextScope *
 210     GetSymbolContextScope()
 211     {
 212         return m_context;
 213     }
 214     const SymbolContextScope *
 215     GetSymbolContextScope() const
 216     {
 217         return m_context;
 218     }
 219     void
 220     SetSymbolContextScope(SymbolContextScope *context)
 221     {
 222         m_context = context;
 223     }
 224
 225     const lldb_private::Declaration &
 226     GetDeclaration () const;
 227
 228     // Get the clang type, and resolve definitions for any
 229     // class/struct/union/enum types completely.
 230     ClangASTType
 231     GetClangFullType ();
 232
 233     // Get the clang type, and resolve definitions enough so that the type could
 234     // have layout performed. This allows ptrs and refs to class/struct/union/enum
 235     // types remain forward declarations.
 236     ClangASTType
 237     GetClangLayoutType ();
 238
 239     // Get the clang type and leave class/struct/union/enum types as forward
 240     // declarations if they haven't already been fully defined.
 241     ClangASTType
 242     GetClangForwardType ();
 243
 244     ClangASTContext &
 245     GetClangASTContext ();
 246
 247     static int
 248     Compare(const Type &a, const Type &b);
 249
 250     // From a fully qualified typename, split the type into the type basename
 251     // and the remaining type scope (namespaces/classes).
 252     static bool
 253     GetTypeScopeAndBasename (const char* &name_cstr,
 254                              std::string &scope,
 255                              std::string &basename,
 256                              lldb::TypeClass &type_class);
 257     void
 258     SetEncodingType (Type *encoding_type)
 259     {
 260         m_encoding_type = encoding_type;
 261     }
 262
 263     uint32_t
 264     GetEncodingMask ();
 265
 266     ClangASTType
 267     CreateClangTypedefType (Type *typedef_type, Type *base_type);
 268
 269     bool
 270     IsRealObjCClass();
 271
 272     bool
 273     IsCompleteObjCClass()
 274     {
 275         return m_flags.is_complete_objc_class;
 276     }
 277
 278     void
 279     SetIsCompleteObjCClass(bool is_complete_objc_class)
 280     {
 281         m_flags.is_complete_objc_class = is_complete_objc_class;
 282     }
 283
 284 protected:
 285     ConstString m_name;
 286     SymbolFile *m_symbol_file;
 287     SymbolContextScope *m_context; // The symbol context in which this type is defined
 288     Type *m_encoding_type;
 289     lldb::user_id_t m_encoding_uid;
 290     EncodingDataType m_encoding_uid_type;
 291     uint64_t m_byte_size;
 292     Declaration m_decl;
 293     ClangASTType m_clang_type;
 294
 295     struct Flags {
 296         ResolveState    clang_type_resolve_state : 2;
 297         bool            is_complete_objc_class   : 1;
 298     } m_flags;
 299
 300     Type *
 301     GetEncodingType ();
 302
 303     bool
 304     ResolveClangType (ResolveState clang_type_resolve_state);
 305 };
 306
 307 // these classes are used to back the SBType* objects
 308
 309 class TypePair {
 310 private:
 311     ClangASTType clang_type;
 312     lldb::TypeSP type_sp;
 313
 314 public:
 315     TypePair () : clang_type(), type_sp() {}
 316     TypePair (ClangASTType type) :
 317     clang_type(type),
 318     type_sp()
 319     {
 320     }
 321
 322     TypePair (lldb::TypeSP type) :
 323     clang_type(),
 324     type_sp(type)
 325     {
 326         clang_type = type_sp->GetClangForwardType();
 327     }
 328
 329     bool
 330     IsValid () const
 331     {
 332         return clang_type.IsValid() || (type_sp.get() != nullptr);
 333     }
 334
 335     explicit operator bool () const
 336     {
 337         return IsValid();
 338     }
 339
 340     bool
 341     operator == (const TypePair& rhs) const
 342     {
 343         return clang_type == rhs.clang_type &&
 344         type_sp.get() == rhs.type_sp.get();
 345     }
 346
 347     bool
 348     operator != (const TypePair& rhs) const
 349     {
 350         return clang_type != rhs.clang_type ||
 351         type_sp.get() != rhs.type_sp.get();
 352     }
 353
 354     void
 355     Clear ()
 356     {
 357         clang_type.Clear();
 358         type_sp.reset();
 359     }
 360
 361     ConstString
 362     GetName () const
 363     {
 364         if (type_sp)
 365             return type_sp->GetName();
 366         if (clang_type)
 367             return clang_type.GetTypeName();
 368         return ConstString ();
 369     }
 370
 371     void
 372     SetType (ClangASTType type)
 373     {
 374         type_sp.reset();
 375         clang_type = type;
 376     }
 377
 378     void
 379     SetType (lldb::TypeSP type)
 380     {
 381         type_sp = type;
 382         clang_type = type_sp->GetClangForwardType();
 383     }
 384
 385     lldb::TypeSP
 386     GetTypeSP () const
 387     {
 388         return type_sp;
 389     }
 390
 391     ClangASTType
 392     GetClangASTType () const
 393     {
 394         return clang_type;
 395     }
 396
 397     ClangASTType
 398     GetPointerType () const
 399     {
 400         if (type_sp)
 401             return type_sp->GetClangLayoutType().GetPointerType();
 402         return clang_type.GetPointerType();
 403     }
 404
 405     ClangASTType
 406     GetPointeeType () const
 407     {
 408         if (type_sp)
 409             return type_sp->GetClangFullType().GetPointeeType();
 410         return clang_type.GetPointeeType();
 411     }
 412
 413     ClangASTType
 414     GetReferenceType () const
 415     {
 416         if (type_sp)
 417             return type_sp->GetClangLayoutType().GetLValueReferenceType();
 418         return clang_type.GetLValueReferenceType();
 419     }
 420
 421     ClangASTType
 422     GetTypedefedType () const
 423     {
 424         if (type_sp)
 425             return type_sp->GetClangFullType().GetTypedefedType();
 426         return clang_type.GetTypedefedType();
 427     }
 428
 429     ClangASTType
 430     GetDereferencedType () const
 431     {
 432         if (type_sp)
 433             return type_sp->GetClangFullType().GetNonReferenceType();
 434         return clang_type.GetNonReferenceType();
 435     }
 436
 437     ClangASTType
 438     GetUnqualifiedType () const
 439     {
 440         if (type_sp)
 441             return type_sp->GetClangLayoutType().GetFullyUnqualifiedType();
 442         return clang_type.GetFullyUnqualifiedType();
 443     }
 444
 445     ClangASTType
 446     GetCanonicalType () const
 447     {
 448         if (type_sp)
 449             return type_sp->GetClangFullType().GetCanonicalType();
 450         return clang_type.GetCanonicalType();
 451     }
 452
 453     clang::ASTContext *
 454     GetClangASTContext () const
 455     {
 456         return clang_type.GetASTContext();
 457     }
 458 };
 459
 460 class TypeImpl
 461 {
 462 public:
 463
 464     TypeImpl();
 465
 466     ~TypeImpl () {}
 467
 468     TypeImpl(const TypeImpl& rhs);
 469
 470     TypeImpl (lldb::TypeSP type_sp);
 471
 472     TypeImpl (ClangASTType clang_type);
 473
 474     TypeImpl (lldb::TypeSP type_sp, ClangASTType dynamic);
 475
 476     TypeImpl (ClangASTType clang_type, ClangASTType dynamic);
 477
 478     TypeImpl (TypePair pair, ClangASTType dynamic);
 479
 480     void
 481     SetType (lldb::TypeSP type_sp);
 482
 483     void
 484     SetType (ClangASTType clang_type);
 485
 486     void
 487     SetType (lldb::TypeSP type_sp, ClangASTType dynamic);
 488
 489     void
 490     SetType (ClangASTType clang_type, ClangASTType dynamic);
 491
 492     void
 493     SetType (TypePair pair, ClangASTType dynamic);
 494
 495     TypeImpl&
 496     operator = (const TypeImpl& rhs);
 497
 498     bool
 499     operator == (const TypeImpl& rhs) const;
 500
 501     bool
 502     operator != (const TypeImpl& rhs) const;
 503
 504     bool
 505     IsValid() const;
 506
 507     explicit operator bool () const;
 508
 509     void Clear();
 510
 511     ConstString
 512     GetName ()  const;
 513
 514     TypeImpl
 515     GetPointerType () const;
 516
 517     TypeImpl
 518     GetPointeeType () const;
 519
 520     TypeImpl
 521     GetReferenceType () const;
 522
 523     TypeImpl
 524     GetTypedefedType () const;
 525
 526     TypeImpl
 527     GetDereferencedType () const;
 528
 529     TypeImpl
 530     GetUnqualifiedType() const;
 531
 532     TypeImpl
 533     GetCanonicalType() const;
 534
 535     ClangASTType
 536     GetClangASTType (bool prefer_dynamic);
 537
 538     clang::ASTContext *
 539     GetClangASTContext (bool prefer_dynamic);
 540
 541     bool
 542     GetDescription (lldb_private::Stream &strm,
 543                     lldb::DescriptionLevel description_level);
 544
 545 private:
 546     TypePair m_static_type;
 547     ClangASTType m_dynamic_type;
 548 };
 549
 550 class TypeListImpl
 551 {
 552 public:
 553     TypeListImpl() :
 554         m_content()
 555     {
 556     }
 557
 558     void
 559     Append (const lldb::TypeImplSP& type)
 560     {
 561         m_content.push_back(type);
 562     }
 563
 564     class AppendVisitor
 565     {
 566     public:
 567         AppendVisitor(TypeListImpl &type_list) :
 568             m_type_list(type_list)
 569         {
 570         }
 571
 572         void
 573         operator() (const lldb::TypeImplSP& type)
 574         {
 575             m_type_list.Append(type);
 576         }
 577
 578     private:
 579         TypeListImpl &m_type_list;
 580     };
 581
 582     void
 583     Append (const lldb_private::TypeList &type_list);
 584
 585     lldb::TypeImplSP
 586     GetTypeAtIndex(size_t idx)
 587     {
 588         lldb::TypeImplSP type_sp;
 589         if (idx < GetSize())
 590             type_sp = m_content[idx];
 591         return type_sp;
 592     }
 593
 594     size_t
 595     GetSize()
 596     {
 597         return m_content.size();
 598     }
 599
 600 private:
 601     std::vector<lldb::TypeImplSP> m_content;
 602 };
 603
 604 class TypeMemberImpl
 605 {
 606 public:
 607     TypeMemberImpl () :
 608         m_type_impl_sp (),
 609         m_bit_offset (0),
 610         m_name (),
 611         m_bitfield_bit_size (0),
 612         m_is_bitfield (false)
 613
 614     {
 615     }
 616
 617     TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp,
 618                     uint64_t bit_offset,
 619                     const ConstString &name,
 620                     uint32_t bitfield_bit_size = 0,
 621                     bool is_bitfield = false) :
 622         m_type_impl_sp (type_impl_sp),
 623         m_bit_offset (bit_offset),
 624         m_name (name),
 625         m_bitfield_bit_size (bitfield_bit_size),
 626         m_is_bitfield (is_bitfield)
 627     {
 628     }
 629
 630     TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp,
 631                     uint64_t bit_offset):
 632         m_type_impl_sp (type_impl_sp),
 633         m_bit_offset (bit_offset),
 634         m_name (),
 635         m_bitfield_bit_size (0),
 636         m_is_bitfield (false)
 637     {
 638         if (m_type_impl_sp)
 639             m_name = m_type_impl_sp->GetName();
 640     }
 641
 642     const lldb::TypeImplSP &
 643     GetTypeImpl ()
 644     {
 645         return m_type_impl_sp;
 646     }
 647
 648     const ConstString &
 649     GetName () const
 650     {
 651         return m_name;
 652     }
 653
 654     uint64_t
 655     GetBitOffset () const
 656     {
 657         return m_bit_offset;
 658     }
 659
 660     uint32_t
 661     GetBitfieldBitSize () const
 662     {
 663         return m_bitfield_bit_size;
 664     }
 665
 666     void
 667     SetBitfieldBitSize (uint32_t bitfield_bit_size)
 668     {
 669         m_bitfield_bit_size = bitfield_bit_size;
 670     }
 671
 672     bool
 673     GetIsBitfield () const
 674     {
 675         return m_is_bitfield;
 676     }
 677
 678     void
 679     SetIsBitfield (bool is_bitfield)
 680     {
 681         m_is_bitfield = is_bitfield;
 682     }
 683
 684 protected:
 685     lldb::TypeImplSP m_type_impl_sp;
 686     uint64_t m_bit_offset;
 687     ConstString m_name;
 688     uint32_t m_bitfield_bit_size; // Bit size for bitfield members only
 689     bool m_is_bitfield;
 690 };
 691
 692
 693 ///
 694 /// Sometimes you can find the name of the type corresponding to an object, but we don't have debug
 695 /// information for it.  If that is the case, you can return one of these objects, and then if it
 696 /// has a full type, you can use that, but if not at least you can print the name for informational
 697 /// purposes.
 698 ///
 699
 700 class TypeAndOrName
 701 {
 702 public:
 703     TypeAndOrName ();
 704     TypeAndOrName (lldb::TypeSP &type_sp);
 705     TypeAndOrName (const ClangASTType &clang_type);
 706     TypeAndOrName (const char *type_str);
 707     TypeAndOrName (const TypeAndOrName &rhs);
 708     TypeAndOrName (ConstString &type_const_string);
 709
 710     TypeAndOrName &
 711     operator= (const TypeAndOrName &rhs);
 712
 713     bool
 714     operator==(const TypeAndOrName &other) const;
 715
 716     bool
 717     operator!=(const TypeAndOrName &other) const;
 718
 719     ConstString GetName () const;
 720
 721     lldb::TypeSP
 722     GetTypeSP () const
 723     {
 724         return m_type_pair.GetTypeSP();
 725     }
 726
 727     ClangASTType
 728     GetClangASTType () const
 729     {
 730         return m_type_pair.GetClangASTType();
 731     }
 732
 733     void
 734     SetName (const ConstString &type_name);
 735
 736     void
 737     SetName (const char *type_name_cstr);
 738
 739     void
 740     SetTypeSP (lldb::TypeSP type_sp);
 741
 742     void
 743     SetClangASTType (ClangASTType clang_type);
 744
 745     bool
 746     IsEmpty () const;
 747
 748     bool
 749     HasName () const;
 750
 751     bool
 752     HasTypeSP () const;
 753
 754     bool
 755     HasClangASTType () const;
 756
 757     bool
 758     HasType () const
 759     {
 760         return HasTypeSP() || HasClangASTType();
 761     }
 762
 763     void
 764     Clear ();
 765
 766     explicit operator bool ()
 767     {
 768         return !IsEmpty();
 769     }
 770
 771 private:
 772     TypePair m_type_pair;
 773     ConstString m_type_name;
 774 };
 775
 776 } // namespace lldb_private
 777
 778 #endif  // liblldb_Type_h_
 779