contrib/llvm-project/lldb/include/lldb/Symbol/CompilerType.h

   1 //===-- CompilerType.h ------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef liblldb_CompilerType_h_
  10 #define liblldb_CompilerType_h_
  11
  12 #include <functional>
  13 #include <string>
  14 #include <vector>
  15
  16 #include "lldb/lldb-private.h"
  17 #include "llvm/ADT/APSInt.h"
  18
  19 namespace lldb_private {
  20
  21 class DataExtractor;
  22
  23 /// Represents a generic type in a programming language.
  24 ///
  25 /// This class serves as an abstraction for a type inside one of the TypeSystems
  26 /// implemented by the language plugins. It does not have any actual logic in it
  27 /// but only stores an opaque pointer and a pointer to the TypeSystem that
  28 /// gives meaning to this opaque pointer. All methods of this class should call
  29 /// their respective method in the TypeSystem interface and pass the opaque
  30 /// pointer along.
  31 ///
  32 /// \see lldb_private::TypeSystem
  33 class CompilerType {
  34 public:
  35   /// Creates a CompilerType with the given TypeSystem and opaque compiler type.
  36   ///
  37   /// This constructor should only be called from the respective TypeSystem
  38   /// implementation.
  39   ///
  40   /// \see lldb_private::ClangASTContext::GetType(clang::QualType)
  41   CompilerType(TypeSystem *type_system, lldb::opaque_compiler_type_t type)
  42       : m_type(type), m_type_system(type_system) {}
  43
  44   CompilerType(const CompilerType &rhs)
  45       : m_type(rhs.m_type), m_type_system(rhs.m_type_system) {}
  46
  47   CompilerType() = default;
  48
  49   // Operators
  50
  51   const CompilerType &operator=(const CompilerType &rhs) {
  52     m_type = rhs.m_type;
  53     m_type_system = rhs.m_type_system;
  54     return *this;
  55   }
  56
  57   // Tests
  58
  59   explicit operator bool() const {
  60     return m_type != nullptr && m_type_system != nullptr;
  61   }
  62
  63   bool operator<(const CompilerType &rhs) const {
  64     if (m_type_system == rhs.m_type_system)
  65       return m_type < rhs.m_type;
  66     return m_type_system < rhs.m_type_system;
  67   }
  68
  69   bool IsValid() const { return m_type != nullptr && m_type_system != nullptr; }
  70
  71   bool IsArrayType(CompilerType *element_type, uint64_t *size,
  72                    bool *is_incomplete) const;
  73
  74   bool IsVectorType(CompilerType *element_type, uint64_t *size) const;
  75
  76   bool IsArrayOfScalarType() const;
  77
  78   bool IsAggregateType() const;
  79
  80   bool IsAnonymousType() const;
  81
  82   bool IsBeingDefined() const;
  83
  84   bool IsCharType() const;
  85
  86   bool IsCompleteType() const;
  87
  88   bool IsConst() const;
  89
  90   bool IsCStringType(uint32_t &length) const;
  91
  92   bool IsDefined() const;
  93
  94   bool IsFloatingPointType(uint32_t &count, bool &is_complex) const;
  95
  96   bool IsFunctionType(bool *is_variadic_ptr = nullptr) const;
  97
  98   uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const;
  99
 100   size_t GetNumberOfFunctionArguments() const;
 101
 102   CompilerType GetFunctionArgumentAtIndex(const size_t index) const;
 103
 104   bool IsVariadicFunctionType() const;
 105
 106   bool IsFunctionPointerType() const;
 107
 108   bool IsBlockPointerType(CompilerType *function_pointer_type_ptr) const;
 109
 110   bool IsIntegerType(bool &is_signed) const;
 111
 112   bool IsEnumerationType(bool &is_signed) const;
 113
 114   bool IsIntegerOrEnumerationType(bool &is_signed) const;
 115
 116   bool IsPolymorphicClass() const;
 117
 118   bool IsPossibleDynamicType(CompilerType *target_type, // Can pass nullptr
 119                              bool check_cplusplus, bool check_objc) const;
 120
 121   bool IsPointerToScalarType() const;
 122
 123   bool IsRuntimeGeneratedType() const;
 124
 125   bool IsPointerType(CompilerType *pointee_type = nullptr) const;
 126
 127   bool IsPointerOrReferenceType(CompilerType *pointee_type = nullptr) const;
 128
 129   bool IsReferenceType(CompilerType *pointee_type = nullptr,
 130                        bool *is_rvalue = nullptr) const;
 131
 132   bool ShouldTreatScalarValueAsAddress() const;
 133
 134   bool IsScalarType() const;
 135
 136   bool IsTypedefType() const;
 137
 138   bool IsVoidType() const;
 139
 140   // Type Completion
 141
 142   bool GetCompleteType() const;
 143
 144   // AST related queries
 145
 146   size_t GetPointerByteSize() const;
 147
 148   // Accessors
 149
 150   TypeSystem *GetTypeSystem() const { return m_type_system; }
 151
 152   ConstString GetConstQualifiedTypeName() const;
 153
 154   ConstString GetConstTypeName() const;
 155
 156   ConstString GetTypeName() const;
 157
 158   ConstString GetDisplayTypeName() const;
 159
 160   uint32_t
 161   GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) const;
 162
 163   lldb::LanguageType GetMinimumLanguage();
 164
 165   lldb::opaque_compiler_type_t GetOpaqueQualType() const { return m_type; }
 166
 167   lldb::TypeClass GetTypeClass() const;
 168
 169   void SetCompilerType(TypeSystem *type_system,
 170                        lldb::opaque_compiler_type_t type);
 171
 172   unsigned GetTypeQualifiers() const;
 173
 174   // Creating related types
 175
 176   CompilerType GetArrayElementType(uint64_t *stride = nullptr) const;
 177
 178   CompilerType GetArrayType(uint64_t size) const;
 179
 180   CompilerType GetCanonicalType() const;
 181
 182   CompilerType GetFullyUnqualifiedType() const;
 183
 184   // Returns -1 if this isn't a function of if the function doesn't have a
 185   // prototype Returns a value >= 0 if there is a prototype.
 186   int GetFunctionArgumentCount() const;
 187
 188   CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const;
 189
 190   CompilerType GetFunctionReturnType() const;
 191
 192   size_t GetNumMemberFunctions() const;
 193
 194   TypeMemberFunctionImpl GetMemberFunctionAtIndex(size_t idx);
 195
 196   // If this type is a reference to a type (L value or R value reference),
 197   // return a new type with the reference removed, else return the current type
 198   // itself.
 199   CompilerType GetNonReferenceType() const;
 200
 201   // If this type is a pointer type, return the type that the pointer points
 202   // to, else return an invalid type.
 203   CompilerType GetPointeeType() const;
 204
 205   // Return a new CompilerType that is a pointer to this type
 206   CompilerType GetPointerType() const;
 207
 208   // Return a new CompilerType that is a L value reference to this type if this
 209   // type is valid and the type system supports L value references, else return
 210   // an invalid type.
 211   CompilerType GetLValueReferenceType() const;
 212
 213   // Return a new CompilerType that is a R value reference to this type if this
 214   // type is valid and the type system supports R value references, else return
 215   // an invalid type.
 216   CompilerType GetRValueReferenceType() const;
 217
 218   // Return a new CompilerType adds a const modifier to this type if this type
 219   // is valid and the type system supports const modifiers, else return an
 220   // invalid type.
 221   CompilerType AddConstModifier() const;
 222
 223   // Return a new CompilerType adds a volatile modifier to this type if this
 224   // type is valid and the type system supports volatile modifiers, else return
 225   // an invalid type.
 226   CompilerType AddVolatileModifier() const;
 227
 228   // Return a new CompilerType that is the atomic type of this type. If this
 229   // type is not valid or the type system doesn't support atomic types, this
 230   // returns an invalid type.
 231   CompilerType GetAtomicType() const;
 232
 233   // Return a new CompilerType adds a restrict modifier to this type if this
 234   // type is valid and the type system supports restrict modifiers, else return
 235   // an invalid type.
 236   CompilerType AddRestrictModifier() const;
 237
 238   // Create a typedef to this type using "name" as the name of the typedef this
 239   // type is valid and the type system supports typedefs, else return an
 240   // invalid type.
 241   CompilerType CreateTypedef(const char *name,
 242                              const CompilerDeclContext &decl_ctx) const;
 243
 244   // If the current object represents a typedef type, get the underlying type
 245   CompilerType GetTypedefedType() const;
 246
 247   // Create related types using the current type's AST
 248   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const;
 249
 250   // Exploring the type
 251
 252   struct IntegralTemplateArgument;
 253
 254   /// Return the size of the type in bytes.
 255   llvm::Optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope) const;
 256   /// Return the size of the type in bits.
 257   llvm::Optional<uint64_t> GetBitSize(ExecutionContextScope *exe_scope) const;
 258
 259   lldb::Encoding GetEncoding(uint64_t &count) const;
 260
 261   lldb::Format GetFormat() const;
 262
 263   llvm::Optional<size_t> GetTypeBitAlign(ExecutionContextScope *exe_scope) const;
 264
 265   uint32_t GetNumChildren(bool omit_empty_base_classes,
 266                           const ExecutionContext *exe_ctx) const;
 267
 268   lldb::BasicType GetBasicTypeEnumeration() const;
 269
 270   static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
 271
 272   // If this type is an enumeration, iterate through all of its enumerators
 273   // using a callback. If the callback returns true, keep iterating, else abort
 274   // the iteration.
 275   void ForEachEnumerator(
 276       std::function<bool(const CompilerType &integer_type,
 277                          ConstString name,
 278                          const llvm::APSInt &value)> const &callback) const;
 279
 280   uint32_t GetNumFields() const;
 281
 282   CompilerType GetFieldAtIndex(size_t idx, std::string &name,
 283                                uint64_t *bit_offset_ptr,
 284                                uint32_t *bitfield_bit_size_ptr,
 285                                bool *is_bitfield_ptr) const;
 286
 287   uint32_t GetNumDirectBaseClasses() const;
 288
 289   uint32_t GetNumVirtualBaseClasses() const;
 290
 291   CompilerType GetDirectBaseClassAtIndex(size_t idx,
 292                                          uint32_t *bit_offset_ptr) const;
 293
 294   CompilerType GetVirtualBaseClassAtIndex(size_t idx,
 295                                           uint32_t *bit_offset_ptr) const;
 296
 297   uint32_t GetIndexOfFieldWithName(const char *name,
 298                                    CompilerType *field_compiler_type = nullptr,
 299                                    uint64_t *bit_offset_ptr = nullptr,
 300                                    uint32_t *bitfield_bit_size_ptr = nullptr,
 301                                    bool *is_bitfield_ptr = nullptr) const;
 302
 303   CompilerType GetChildCompilerTypeAtIndex(
 304       ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
 305       bool omit_empty_base_classes, bool ignore_array_bounds,
 306       std::string &child_name, uint32_t &child_byte_size,
 307       int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
 308       uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
 309       bool &child_is_deref_of_parent, ValueObject *valobj,
 310       uint64_t &language_flags) const;
 311
 312   // Lookup a child given a name. This function will match base class names and
 313   // member member names in "clang_type" only, not descendants.
 314   uint32_t GetIndexOfChildWithName(const char *name,
 315                                    bool omit_empty_base_classes) const;
 316
 317   // Lookup a child member given a name. This function will match member names
 318   // only and will descend into "clang_type" children in search for the first
 319   // member in this class, or any base class that matches "name".
 320   // TODO: Return all matches for a given name by returning a
 321   // vector<vector<uint32_t>>
 322   // so we catch all names that match a given child name, not just the first.
 323   size_t
 324   GetIndexOfChildMemberWithName(const char *name, bool omit_empty_base_classes,
 325                                 std::vector<uint32_t> &child_indexes) const;
 326
 327   size_t GetNumTemplateArguments() const;
 328
 329   lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
 330   CompilerType GetTypeTemplateArgument(size_t idx) const;
 331
 332   // Returns the value of the template argument and its type.
 333   llvm::Optional<IntegralTemplateArgument>
 334   GetIntegralTemplateArgument(size_t idx) const;
 335
 336   CompilerType GetTypeForFormatters() const;
 337
 338   LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;
 339
 340   bool IsMeaninglessWithoutDynamicResolution() const;
 341
 342   // Dumping types
 343
 344 #ifndef NDEBUG
 345   /// Convenience LLVM-style dump method for use in the debugger only.
 346   /// Don't call this function from actual code.
 347   LLVM_DUMP_METHOD void dump() const;
 348 #endif
 349
 350   void DumpValue(ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
 351                  const DataExtractor &data, lldb::offset_t data_offset,
 352                  size_t data_byte_size, uint32_t bitfield_bit_size,
 353                  uint32_t bitfield_bit_offset, bool show_types,
 354                  bool show_summary, bool verbose, uint32_t depth);
 355
 356   bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data,
 357                      lldb::offset_t data_offset, size_t data_byte_size,
 358                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
 359                      ExecutionContextScope *exe_scope);
 360
 361   void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
 362                    const DataExtractor &data, lldb::offset_t data_offset,
 363                    size_t data_byte_size);
 364
 365   void DumpTypeDescription() const; // Dump to stdout
 366
 367   void DumpTypeDescription(Stream *s) const;
 368
 369   bool GetValueAsScalar(const DataExtractor &data, lldb::offset_t data_offset,
 370                         size_t data_byte_size, Scalar &value) const;
 371
 372   void Clear() {
 373     m_type = nullptr;
 374     m_type_system = nullptr;
 375   }
 376
 377 private:
 378   lldb::opaque_compiler_type_t m_type = nullptr;
 379   TypeSystem *m_type_system = nullptr;
 380 };
 381
 382 bool operator==(const CompilerType &lhs, const CompilerType &rhs);
 383 bool operator!=(const CompilerType &lhs, const CompilerType &rhs);
 384
 385 struct CompilerType::IntegralTemplateArgument {
 386   llvm::APSInt value;
 387   CompilerType type;
 388 };
 389
 390 } // namespace lldb_private
 391
 392 #endif // liblldb_CompilerType_h_