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

   1 //===-- CompilerType.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_CompilerType_h_
  11 #define liblldb_CompilerType_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <functional>
  16 #include <string>
  17 #include <vector>
  18
  19 // Other libraries and framework includes
  20 // Project includes
  21 #include "lldb/lldb-private.h"
  22 #include "lldb/Core/ClangForward.h"
  23
  24 namespace lldb_private {
  25
  26 //----------------------------------------------------------------------
  27 // A class that can carry around a clang ASTContext and a opaque clang
  28 // QualType. A clang::QualType can be easily reconstructed from an
  29 // opaque clang type and often the ASTContext is needed when doing
  30 // various type related tasks, so this class allows both items to travel
  31 // in a single very lightweight class that can be used. There are many
  32 // static equivalents of the member functions that allow the ASTContext
  33 // and the opaque clang QualType to be specified for ease of use and
  34 // to avoid code duplication.
  35 //----------------------------------------------------------------------
  36 class CompilerType
  37 {
  38 public:
  39     //----------------------------------------------------------------------
  40     // Constructors and Destructors
  41     //----------------------------------------------------------------------
  42     CompilerType (TypeSystem *type_system, lldb::opaque_compiler_type_t type);
  43     CompilerType (clang::ASTContext *ast_context, clang::QualType qual_type);
  44
  45     CompilerType (const CompilerType &rhs) :
  46         m_type (rhs.m_type),
  47         m_type_system  (rhs.m_type_system)
  48     {
  49     }
  50
  51     CompilerType () :
  52         m_type (nullptr),
  53         m_type_system (nullptr)
  54     {
  55     }
  56
  57     ~CompilerType();
  58
  59     //----------------------------------------------------------------------
  60     // Operators
  61     //----------------------------------------------------------------------
  62
  63     const CompilerType &
  64     operator= (const CompilerType &rhs)
  65     {
  66         m_type = rhs.m_type;
  67         m_type_system = rhs.m_type_system;
  68         return *this;
  69     }
  70
  71     //----------------------------------------------------------------------
  72     // Tests
  73     //----------------------------------------------------------------------
  74
  75     explicit operator bool () const
  76     {
  77         return m_type != nullptr && m_type_system != nullptr;
  78     }
  79
  80     bool
  81     operator < (const CompilerType &rhs) const
  82     {
  83         if (m_type_system == rhs.m_type_system)
  84             return m_type < rhs.m_type;
  85         return m_type_system < rhs.m_type_system;
  86     }
  87
  88     bool
  89     IsValid () const
  90     {
  91         return m_type != nullptr && m_type_system != nullptr;
  92     }
  93
  94     bool
  95     IsArrayType (CompilerType *element_type,
  96                  uint64_t *size,
  97                  bool *is_incomplete) const;
  98
  99     bool
 100     IsVectorType (CompilerType *element_type,
 101                   uint64_t *size) const;
 102
 103     bool
 104     IsArrayOfScalarType () const;
 105
 106     bool
 107     IsAggregateType () const;
 108
 109     bool
 110     IsAnonymousType () const;
 111
 112     bool
 113     IsBeingDefined () const;
 114
 115     bool
 116     IsCharType () const;
 117
 118     bool
 119     IsCompleteType () const;
 120
 121     bool
 122     IsConst() const;
 123
 124     bool
 125     IsCStringType (uint32_t &length) const;
 126
 127     bool
 128     IsDefined() const;
 129
 130     bool
 131     IsFloatingPointType (uint32_t &count, bool &is_complex) const;
 132
 133     bool
 134     IsFunctionType(bool *is_variadic_ptr = nullptr) const;
 135
 136     uint32_t
 137     IsHomogeneousAggregate (CompilerType* base_type_ptr) const;
 138
 139     size_t
 140     GetNumberOfFunctionArguments () const;
 141
 142     CompilerType
 143     GetFunctionArgumentAtIndex (const size_t index) const;
 144
 145     bool
 146     IsVariadicFunctionType () const;
 147
 148     bool
 149     IsFunctionPointerType () const;
 150
 151     bool
 152     IsIntegerType (bool &is_signed) const;
 153
 154     bool
 155     IsPolymorphicClass () const;
 156
 157     bool
 158     IsPossibleCPlusPlusDynamicType(CompilerType *target_type = nullptr) const
 159     {
 160         return IsPossibleDynamicType (target_type, true, false);
 161     }
 162
 163     bool
 164     IsPossibleDynamicType(CompilerType *target_type, // Can pass nullptr
 165                           bool check_cplusplus,
 166                           bool check_objc) const;
 167
 168     bool
 169     IsPointerToScalarType () const;
 170
 171     bool
 172     IsRuntimeGeneratedType () const;
 173
 174     bool
 175     IsPointerType(CompilerType *pointee_type = nullptr) const;
 176
 177     bool
 178     IsPointerOrReferenceType(CompilerType *pointee_type = nullptr) const;
 179
 180     bool
 181     IsReferenceType(CompilerType *pointee_type = nullptr, bool* is_rvalue = nullptr) const;
 182
 183     bool
 184     ShouldTreatScalarValueAsAddress () const;
 185
 186     bool
 187     IsScalarType () const;
 188
 189     bool
 190     IsTypedefType () const;
 191
 192     bool
 193     IsVoidType () const;
 194
 195     //----------------------------------------------------------------------
 196     // Type Completion
 197     //----------------------------------------------------------------------
 198
 199     bool
 200     GetCompleteType () const;
 201
 202     //----------------------------------------------------------------------
 203     // AST related queries
 204     //----------------------------------------------------------------------
 205
 206     size_t
 207     GetPointerByteSize () const;
 208
 209     //----------------------------------------------------------------------
 210     // Accessors
 211     //----------------------------------------------------------------------
 212
 213     TypeSystem *
 214     GetTypeSystem() const
 215     {
 216         return m_type_system;
 217     }
 218
 219     ConstString
 220     GetConstQualifiedTypeName () const;
 221
 222     ConstString
 223     GetConstTypeName () const;
 224
 225     ConstString
 226     GetTypeName () const;
 227
 228     ConstString
 229     GetDisplayTypeName () const;
 230
 231     uint32_t
 232     GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) const;
 233
 234     lldb::LanguageType
 235     GetMinimumLanguage ();
 236
 237     lldb::opaque_compiler_type_t
 238     GetOpaqueQualType() const
 239     {
 240         return m_type;
 241     }
 242
 243     lldb::TypeClass
 244     GetTypeClass () const;
 245
 246     void
 247     SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type);
 248
 249     void
 250     SetCompilerType (clang::ASTContext *ast, clang::QualType qual_type);
 251
 252     unsigned
 253     GetTypeQualifiers() const;
 254
 255     //----------------------------------------------------------------------
 256     // Creating related types
 257     //----------------------------------------------------------------------
 258
 259     CompilerType
 260     GetArrayElementType(uint64_t *stride = nullptr) const;
 261
 262     CompilerType
 263     GetCanonicalType () const;
 264
 265     CompilerType
 266     GetFullyUnqualifiedType () const;
 267
 268     // Returns -1 if this isn't a function of if the function doesn't have a prototype
 269     // Returns a value >= 0 if there is a prototype.
 270     int
 271     GetFunctionArgumentCount () const;
 272
 273     CompilerType
 274     GetFunctionArgumentTypeAtIndex (size_t idx) const;
 275
 276     CompilerType
 277     GetFunctionReturnType () const;
 278
 279     size_t
 280     GetNumMemberFunctions () const;
 281
 282     TypeMemberFunctionImpl
 283     GetMemberFunctionAtIndex (size_t idx);
 284
 285     //----------------------------------------------------------------------
 286     // If this type is a reference to a type (L value or R value reference),
 287     // return a new type with the reference removed, else return the current
 288     // type itself.
 289     //----------------------------------------------------------------------
 290     CompilerType
 291     GetNonReferenceType () const;
 292
 293     //----------------------------------------------------------------------
 294     // If this type is a pointer type, return the type that the pointer
 295     // points to, else return an invalid type.
 296     //----------------------------------------------------------------------
 297     CompilerType
 298     GetPointeeType () const;
 299
 300     //----------------------------------------------------------------------
 301     // Return a new CompilerType that is a pointer to this type
 302     //----------------------------------------------------------------------
 303     CompilerType
 304     GetPointerType () const;
 305
 306     //----------------------------------------------------------------------
 307     // Return a new CompilerType that is a L value reference to this type if
 308     // this type is valid and the type system supports L value references,
 309     // else return an invalid type.
 310     //----------------------------------------------------------------------
 311     CompilerType
 312     GetLValueReferenceType () const;
 313
 314     //----------------------------------------------------------------------
 315     // Return a new CompilerType that is a R value reference to this type if
 316     // this type is valid and the type system supports R value references,
 317     // else return an invalid type.
 318     //----------------------------------------------------------------------
 319     CompilerType
 320     GetRValueReferenceType () const;
 321
 322     //----------------------------------------------------------------------
 323     // Return a new CompilerType adds a const modifier to this type if
 324     // this type is valid and the type system supports const modifiers,
 325     // else return an invalid type.
 326     //----------------------------------------------------------------------
 327     CompilerType
 328     AddConstModifier () const;
 329
 330     //----------------------------------------------------------------------
 331     // Return a new CompilerType adds a volatile modifier to this type if
 332     // this type is valid and the type system supports volatile modifiers,
 333     // else return an invalid type.
 334     //----------------------------------------------------------------------
 335     CompilerType
 336     AddVolatileModifier () const;
 337
 338     //----------------------------------------------------------------------
 339     // Return a new CompilerType adds a restrict modifier to this type if
 340     // this type is valid and the type system supports restrict modifiers,
 341     // else return an invalid type.
 342     //----------------------------------------------------------------------
 343     CompilerType
 344     AddRestrictModifier () const;
 345
 346     //----------------------------------------------------------------------
 347     // Create a typedef to this type using "name" as the name of the typedef
 348     // this type is valid and the type system supports typedefs, else return
 349     // an invalid type.
 350     //----------------------------------------------------------------------
 351     CompilerType
 352     CreateTypedef (const char *name, const CompilerDeclContext &decl_ctx) const;
 353
 354     // If the current object represents a typedef type, get the underlying type
 355     CompilerType
 356     GetTypedefedType () const;
 357
 358     //----------------------------------------------------------------------
 359     // Create related types using the current type's AST
 360     //----------------------------------------------------------------------
 361     CompilerType
 362     GetBasicTypeFromAST (lldb::BasicType basic_type) const;
 363
 364     //----------------------------------------------------------------------
 365     // Exploring the type
 366     //----------------------------------------------------------------------
 367
 368     uint64_t
 369     GetByteSize (ExecutionContextScope *exe_scope) const;
 370
 371     uint64_t
 372     GetBitSize (ExecutionContextScope *exe_scope) const;
 373
 374     lldb::Encoding
 375     GetEncoding (uint64_t &count) const;
 376
 377     lldb::Format
 378     GetFormat () const;
 379
 380     size_t
 381     GetTypeBitAlign () const;
 382
 383     uint32_t
 384     GetNumChildren (bool omit_empty_base_classes) const;
 385
 386     lldb::BasicType
 387     GetBasicTypeEnumeration () const;
 388
 389     static lldb::BasicType
 390     GetBasicTypeEnumeration (const ConstString &name);
 391
 392     //----------------------------------------------------------------------
 393     // If this type is an enumeration, iterate through all of its enumerators
 394     // using a callback. If the callback returns true, keep iterating, else
 395     // abort the iteration.
 396     //----------------------------------------------------------------------
 397     void
 398     ForEachEnumerator (std::function <bool (const CompilerType &integer_type,
 399                                             const ConstString &name,
 400                                             const llvm::APSInt &value)> const &callback) const;
 401
 402     uint32_t
 403     GetNumFields () const;
 404
 405     CompilerType
 406     GetFieldAtIndex (size_t idx,
 407                      std::string& name,
 408                      uint64_t *bit_offset_ptr,
 409                      uint32_t *bitfield_bit_size_ptr,
 410                      bool *is_bitfield_ptr) const;
 411
 412     uint32_t
 413     GetNumDirectBaseClasses () const;
 414
 415     uint32_t
 416     GetNumVirtualBaseClasses () const;
 417
 418     CompilerType
 419     GetDirectBaseClassAtIndex (size_t idx,
 420                                uint32_t *bit_offset_ptr) const;
 421
 422     CompilerType
 423     GetVirtualBaseClassAtIndex (size_t idx,
 424                                 uint32_t *bit_offset_ptr) const;
 425
 426     uint32_t
 427     GetIndexOfFieldWithName(const char* name,
 428                             CompilerType* field_compiler_type = nullptr,
 429                             uint64_t *bit_offset_ptr = nullptr,
 430                             uint32_t *bitfield_bit_size_ptr = nullptr,
 431                             bool *is_bitfield_ptr = nullptr) const;
 432
 433     CompilerType
 434     GetChildCompilerTypeAtIndex (ExecutionContext *exe_ctx,
 435                                  size_t idx,
 436                                  bool transparent_pointers,
 437                                  bool omit_empty_base_classes,
 438                                  bool ignore_array_bounds,
 439                                  std::string& child_name,
 440                                  uint32_t &child_byte_size,
 441                                  int32_t &child_byte_offset,
 442                                  uint32_t &child_bitfield_bit_size,
 443                                  uint32_t &child_bitfield_bit_offset,
 444                                  bool &child_is_base_class,
 445                                  bool &child_is_deref_of_parent,
 446                                  ValueObject *valobj,
 447                                  uint64_t &language_flags) const;
 448
 449     // Lookup a child given a name. This function will match base class names
 450     // and member member names in "clang_type" only, not descendants.
 451     uint32_t
 452     GetIndexOfChildWithName (const char *name,
 453                              bool omit_empty_base_classes) const;
 454
 455     // Lookup a child member given a name. This function will match member names
 456     // only and will descend into "clang_type" children in search for the first
 457     // member in this class, or any base class that matches "name".
 458     // TODO: Return all matches for a given name by returning a vector<vector<uint32_t>>
 459     // so we catch all names that match a given child name, not just the first.
 460     size_t
 461     GetIndexOfChildMemberWithName (const char *name,
 462                                    bool omit_empty_base_classes,
 463                                    std::vector<uint32_t>& child_indexes) const;
 464
 465     size_t
 466     GetNumTemplateArguments () const;
 467
 468     CompilerType
 469     GetTemplateArgument (size_t idx,
 470                          lldb::TemplateArgumentKind &kind) const;
 471
 472     CompilerType
 473     GetTypeForFormatters () const;
 474
 475     LazyBool
 476     ShouldPrintAsOneLiner (ValueObject* valobj) const;
 477
 478     bool
 479     IsMeaninglessWithoutDynamicResolution () const;
 480
 481     //------------------------------------------------------------------
 482     // Pointers & References
 483     //------------------------------------------------------------------
 484
 485     // Converts "s" to a floating point value and place resulting floating
 486     // point bytes in the "dst" buffer.
 487     size_t
 488     ConvertStringToFloatValue (const char *s,
 489                                uint8_t *dst,
 490                                size_t dst_size) const;
 491
 492     //----------------------------------------------------------------------
 493     // Dumping types
 494     //----------------------------------------------------------------------
 495     void
 496     DumpValue (ExecutionContext *exe_ctx,
 497                Stream *s,
 498                lldb::Format format,
 499                const DataExtractor &data,
 500                lldb::offset_t data_offset,
 501                size_t data_byte_size,
 502                uint32_t bitfield_bit_size,
 503                uint32_t bitfield_bit_offset,
 504                bool show_types,
 505                bool show_summary,
 506                bool verbose,
 507                uint32_t depth);
 508
 509     bool
 510     DumpTypeValue (Stream *s,
 511                    lldb::Format format,
 512                    const DataExtractor &data,
 513                    lldb::offset_t data_offset,
 514                    size_t data_byte_size,
 515                    uint32_t bitfield_bit_size,
 516                    uint32_t bitfield_bit_offset,
 517                    ExecutionContextScope *exe_scope);
 518
 519     void
 520     DumpSummary (ExecutionContext *exe_ctx,
 521                  Stream *s,
 522                  const DataExtractor &data,
 523                  lldb::offset_t data_offset,
 524                  size_t data_byte_size);
 525
 526     void
 527     DumpTypeDescription () const; // Dump to stdout
 528
 529     void
 530     DumpTypeDescription (Stream *s) const;
 531
 532     bool
 533     GetValueAsScalar (const DataExtractor &data,
 534                       lldb::offset_t data_offset,
 535                       size_t data_byte_size,
 536                       Scalar &value) const;
 537
 538     bool
 539     SetValueFromScalar (const Scalar &value,
 540                         Stream &strm);
 541
 542     bool
 543     ReadFromMemory (ExecutionContext *exe_ctx,
 544                     lldb::addr_t addr,
 545                     AddressType address_type,
 546                     DataExtractor &data);
 547
 548     bool
 549     WriteToMemory (ExecutionContext *exe_ctx,
 550                    lldb::addr_t addr,
 551                    AddressType address_type,
 552                    StreamString &new_value);
 553
 554     void
 555     Clear()
 556     {
 557         m_type = nullptr;
 558         m_type_system = nullptr;
 559     }
 560
 561 private:
 562     lldb::opaque_compiler_type_t m_type;
 563     TypeSystem *m_type_system;
 564 };
 565
 566 bool operator == (const CompilerType &lhs, const CompilerType &rhs);
 567 bool operator != (const CompilerType &lhs, const CompilerType &rhs);
 568
 569 } // namespace lldb_private
 570
 571 #endif // liblldb_CompilerType_h_