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

   1 //===-- TypeSystem.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_TypeSystem_h_
  10 #define liblldb_TypeSystem_h_
  11
  12 #include <functional>
  13 #include <map>
  14 #include <mutex>
  15 #include <string>
  16
  17 #include "llvm/ADT/APSInt.h"
  18 #include "llvm/Support/Casting.h"
  19
  20 #include "lldb/Core/PluginInterface.h"
  21 #include "lldb/Expression/Expression.h"
  22 #include "lldb/Symbol/CompilerDecl.h"
  23 #include "lldb/Symbol/CompilerDeclContext.h"
  24 #include "lldb/lldb-private.h"
  25
  26 class DWARFDIE;
  27 class DWARFASTParser;
  28 class PDBASTParser;
  29
  30 namespace lldb_private {
  31
  32 // Interface for representing the Type Systems in different languages.
  33 class TypeSystem : public PluginInterface {
  34 public:
  35   // Intrusive type system that allows us to use llvm casting.
  36   //
  37   // To add a new type system:
  38   //
  39   // 1 - Add a new enumeration for llvm casting below for your TypeSystem
  40   //     subclass, here we will use eKindFoo
  41   //
  42   // 2 - Your TypeSystem subclass will inherit from TypeSystem and needs
  43   //     to implement a static classof() function that returns your
  44   //     enumeration:
  45   //
  46   //    class Foo : public lldb_private::TypeSystem
  47   //    {
  48   //        static bool classof(const TypeSystem *ts)
  49   //        {
  50   //            return ts->getKind() == TypeSystem::eKindFoo;
  51   //        }
  52   //    };
  53   //
  54   // 3 - Contruct your TypeSystem subclass with the enumeration from below
  55   //
  56   //    Foo() :
  57   //        TypeSystem(TypeSystem::eKindFoo),
  58   //        ...
  59   //    {
  60   //    }
  61   //
  62   // Then you can use the llvm casting on any "TypeSystem *" to get an instance
  63   // of your subclass.
  64   enum LLVMCastKind {
  65     eKindClang,
  66     eKindSwift,
  67     eKindOCaml,
  68     kNumKinds
  69   };
  70
  71   // Constructors and Destructors
  72   TypeSystem(LLVMCastKind kind);
  73
  74   ~TypeSystem() override;
  75
  76   LLVMCastKind getKind() const { return m_kind; }
  77
  78   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
  79                                            Module *module);
  80
  81   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
  82                                            Target *target);
  83
  84   // Free up any resources associated with this TypeSystem.  Done before
  85   // removing all the TypeSystems from the TypeSystemMap.
  86   virtual void Finalize() {}
  87
  88   virtual DWARFASTParser *GetDWARFParser() { return nullptr; }
  89   virtual PDBASTParser *GetPDBParser() { return nullptr; }
  90
  91   virtual SymbolFile *GetSymbolFile() const { return m_sym_file; }
  92
  93   // Returns true if the symbol file changed during the set accessor.
  94   virtual void SetSymbolFile(SymbolFile *sym_file) { m_sym_file = sym_file; }
  95
  96   // CompilerDecl functions
  97   virtual ConstString DeclGetName(void *opaque_decl) = 0;
  98
  99   virtual ConstString DeclGetMangledName(void *opaque_decl);
 100
 101   virtual CompilerDeclContext DeclGetDeclContext(void *opaque_decl);
 102
 103   virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl);
 104
 105   virtual size_t DeclGetFunctionNumArguments(void *opaque_decl);
 106
 107   virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
 108                                                    size_t arg_idx);
 109
 110   // CompilerDeclContext functions
 111
 112   virtual std::vector<CompilerDecl>
 113   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
 114                             const bool ignore_imported_decls);
 115
 116   virtual bool DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) = 0;
 117
 118   virtual ConstString DeclContextGetName(void *opaque_decl_ctx) = 0;
 119
 120   virtual ConstString
 121   DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) = 0;
 122
 123   virtual bool DeclContextIsClassMethod(
 124       void *opaque_decl_ctx, lldb::LanguageType *language_ptr,
 125       bool *is_instance_method_ptr, ConstString *language_object_name_ptr) = 0;
 126
 127   virtual bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
 128                                               void *other_opaque_decl_ctx) = 0;
 129
 130   // Tests
 131
 132   virtual bool IsArrayType(lldb::opaque_compiler_type_t type,
 133                            CompilerType *element_type, uint64_t *size,
 134                            bool *is_incomplete) = 0;
 135
 136   virtual bool IsAggregateType(lldb::opaque_compiler_type_t type) = 0;
 137
 138   virtual bool IsAnonymousType(lldb::opaque_compiler_type_t type);
 139
 140   virtual bool IsCharType(lldb::opaque_compiler_type_t type) = 0;
 141
 142   virtual bool IsCompleteType(lldb::opaque_compiler_type_t type) = 0;
 143
 144   virtual bool IsDefined(lldb::opaque_compiler_type_t type) = 0;
 145
 146   virtual bool IsFloatingPointType(lldb::opaque_compiler_type_t type,
 147                                    uint32_t &count, bool &is_complex) = 0;
 148
 149   virtual bool IsFunctionType(lldb::opaque_compiler_type_t type,
 150                               bool *is_variadic_ptr) = 0;
 151
 152   virtual size_t
 153   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) = 0;
 154
 155   virtual CompilerType
 156   GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
 157                              const size_t index) = 0;
 158
 159   virtual bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) = 0;
 160
 161   virtual bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
 162                                   CompilerType *function_pointer_type_ptr) = 0;
 163
 164   virtual bool IsIntegerType(lldb::opaque_compiler_type_t type,
 165                              bool &is_signed) = 0;
 166
 167   virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type,
 168                                  bool &is_signed) {
 169     is_signed = false;
 170     return false;
 171   }
 172
 173   virtual bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
 174                                      CompilerType *target_type, // Can pass NULL
 175                                      bool check_cplusplus, bool check_objc) = 0;
 176
 177   virtual bool IsPointerType(lldb::opaque_compiler_type_t type,
 178                              CompilerType *pointee_type) = 0;
 179
 180   virtual bool IsScalarType(lldb::opaque_compiler_type_t type) = 0;
 181
 182   virtual bool IsVoidType(lldb::opaque_compiler_type_t type) = 0;
 183
 184   virtual bool CanPassInRegisters(const CompilerType &type) = 0;
 185
 186   // TypeSystems can support more than one language
 187   virtual bool SupportsLanguage(lldb::LanguageType language) = 0;
 188
 189   // Type Completion
 190
 191   virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) = 0;
 192
 193   // AST related queries
 194
 195   virtual uint32_t GetPointerByteSize() = 0;
 196
 197   // Accessors
 198
 199   virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type) = 0;
 200
 201   virtual uint32_t
 202   GetTypeInfo(lldb::opaque_compiler_type_t type,
 203               CompilerType *pointee_or_element_compiler_type) = 0;
 204
 205   virtual lldb::LanguageType
 206   GetMinimumLanguage(lldb::opaque_compiler_type_t type) = 0;
 207
 208   virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) = 0;
 209
 210   // Creating related types
 211
 212   virtual CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type,
 213                                            uint64_t *stride) = 0;
 214
 215   virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
 216                                     uint64_t size);
 217
 218   virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) = 0;
 219
 220   // Returns -1 if this isn't a function of if the function doesn't have a
 221   // prototype Returns a value >= 0 if there is a prototype.
 222   virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) = 0;
 223
 224   virtual CompilerType
 225   GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
 226                                  size_t idx) = 0;
 227
 228   virtual CompilerType
 229   GetFunctionReturnType(lldb::opaque_compiler_type_t type) = 0;
 230
 231   virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) = 0;
 232
 233   virtual TypeMemberFunctionImpl
 234   GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) = 0;
 235
 236   virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) = 0;
 237
 238   virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) = 0;
 239
 240   virtual CompilerType
 241   GetLValueReferenceType(lldb::opaque_compiler_type_t type);
 242
 243   virtual CompilerType
 244   GetRValueReferenceType(lldb::opaque_compiler_type_t type);
 245
 246   virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type);
 247
 248   virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type);
 249
 250   virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type);
 251
 252   virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
 253                                      const char *name,
 254                                      const CompilerDeclContext &decl_ctx);
 255
 256   // Exploring the type
 257
 258   virtual llvm::Optional<uint64_t>
 259   GetBitSize(lldb::opaque_compiler_type_t type,
 260              ExecutionContextScope *exe_scope) = 0;
 261
 262   virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
 263                                      uint64_t &count) = 0;
 264
 265   virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0;
 266
 267   virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
 268                                   bool omit_empty_base_classes,
 269                                   const ExecutionContext *exe_ctx) = 0;
 270
 271   virtual CompilerType GetBuiltinTypeByName(ConstString name);
 272
 273   virtual lldb::BasicType
 274   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0;
 275
 276   virtual void ForEachEnumerator(
 277       lldb::opaque_compiler_type_t type,
 278       std::function<bool(const CompilerType &integer_type,
 279                          ConstString name,
 280                          const llvm::APSInt &value)> const &callback) {}
 281
 282   virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0;
 283
 284   virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type,
 285                                        size_t idx, std::string &name,
 286                                        uint64_t *bit_offset_ptr,
 287                                        uint32_t *bitfield_bit_size_ptr,
 288                                        bool *is_bitfield_ptr) = 0;
 289
 290   virtual uint32_t
 291   GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) = 0;
 292
 293   virtual uint32_t
 294   GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) = 0;
 295
 296   virtual CompilerType
 297   GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
 298                             uint32_t *bit_offset_ptr) = 0;
 299
 300   virtual CompilerType
 301   GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
 302                              uint32_t *bit_offset_ptr) = 0;
 303
 304   virtual CompilerType GetChildCompilerTypeAtIndex(
 305       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
 306       bool transparent_pointers, bool omit_empty_base_classes,
 307       bool ignore_array_bounds, std::string &child_name,
 308       uint32_t &child_byte_size, int32_t &child_byte_offset,
 309       uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
 310       bool &child_is_base_class, bool &child_is_deref_of_parent,
 311       ValueObject *valobj, uint64_t &language_flags) = 0;
 312
 313   // Lookup a child given a name. This function will match base class names and
 314   // member member names in "clang_type" only, not descendants.
 315   virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
 316                                            const char *name,
 317                                            bool omit_empty_base_classes) = 0;
 318
 319   // Lookup a child member given a name. This function will match member names
 320   // only and will descend into "clang_type" children in search for the first
 321   // member in this class, or any base class that matches "name".
 322   // TODO: Return all matches for a given name by returning a
 323   // vector<vector<uint32_t>>
 324   // so we catch all names that match a given child name, not just the first.
 325   virtual size_t
 326   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
 327                                 const char *name, bool omit_empty_base_classes,
 328                                 std::vector<uint32_t> &child_indexes) = 0;
 329
 330   virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type);
 331
 332   virtual lldb::TemplateArgumentKind
 333   GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx);
 334   virtual CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
 335                                            size_t idx);
 336   virtual llvm::Optional<CompilerType::IntegralTemplateArgument>
 337   GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx);
 338
 339   // Dumping types
 340
 341 #ifndef NDEBUG
 342   /// Convenience LLVM-style dump method for use in the debugger only.
 343   LLVM_DUMP_METHOD virtual void
 344   dump(lldb::opaque_compiler_type_t type) const = 0;
 345 #endif
 346
 347   virtual void DumpValue(lldb::opaque_compiler_type_t type,
 348                          ExecutionContext *exe_ctx, Stream *s,
 349                          lldb::Format format, const DataExtractor &data,
 350                          lldb::offset_t data_offset, size_t data_byte_size,
 351                          uint32_t bitfield_bit_size,
 352                          uint32_t bitfield_bit_offset, bool show_types,
 353                          bool show_summary, bool verbose, uint32_t depth) = 0;
 354
 355   virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
 356                              lldb::Format format, const DataExtractor &data,
 357                              lldb::offset_t data_offset, size_t data_byte_size,
 358                              uint32_t bitfield_bit_size,
 359                              uint32_t bitfield_bit_offset,
 360                              ExecutionContextScope *exe_scope) = 0;
 361
 362   virtual void
 363   DumpTypeDescription(lldb::opaque_compiler_type_t type) = 0; // Dump to stdout
 364
 365   virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type,
 366                                    Stream *s) = 0;
 367
 368   // TODO: These methods appear unused. Should they be removed?
 369
 370   virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) = 0;
 371
 372   virtual void DumpSummary(lldb::opaque_compiler_type_t type,
 373                            ExecutionContext *exe_ctx, Stream *s,
 374                            const DataExtractor &data,
 375                            lldb::offset_t data_offset,
 376                            size_t data_byte_size) = 0;
 377
 378   // Converts "s" to a floating point value and place resulting floating point
 379   // bytes in the "dst" buffer.
 380   virtual size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
 381                                            const char *s, uint8_t *dst,
 382                                            size_t dst_size) = 0;
 383
 384   // TODO: Determine if these methods should move to ClangASTContext.
 385
 386   virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
 387                                         CompilerType *pointee_type) = 0;
 388
 389   virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) = 0;
 390
 391   virtual bool IsCStringType(lldb::opaque_compiler_type_t type,
 392                              uint32_t &length) = 0;
 393
 394   virtual size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) = 0;
 395
 396   virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) = 0;
 397
 398   virtual CompilerType
 399   GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
 400                                       size_t bit_size) = 0;
 401
 402   virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type) = 0;
 403
 404   virtual bool IsConst(lldb::opaque_compiler_type_t type) = 0;
 405
 406   virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
 407                                           CompilerType *base_type_ptr) = 0;
 408
 409   virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) = 0;
 410
 411   virtual bool IsTypedefType(lldb::opaque_compiler_type_t type) = 0;
 412
 413   // If the current object represents a typedef type, get the underlying type
 414   virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) = 0;
 415
 416   virtual bool IsVectorType(lldb::opaque_compiler_type_t type,
 417                             CompilerType *element_type, uint64_t *size) = 0;
 418
 419   virtual CompilerType
 420   GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) = 0;
 421
 422   virtual CompilerType
 423   GetNonReferenceType(lldb::opaque_compiler_type_t type) = 0;
 424
 425   virtual bool IsReferenceType(lldb::opaque_compiler_type_t type,
 426                                CompilerType *pointee_type, bool *is_rvalue) = 0;
 427
 428   virtual bool
 429   ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type) {
 430     return IsPointerOrReferenceType(type, nullptr);
 431   }
 432
 433   virtual UserExpression *
 434   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
 435                     lldb::LanguageType language,
 436                     Expression::ResultType desired_type,
 437                     const EvaluateExpressionOptions &options,
 438                     ValueObject *ctx_obj) {
 439     return nullptr;
 440   }
 441
 442   virtual FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
 443                                             const Address &function_address,
 444                                             const ValueList &arg_value_list,
 445                                             const char *name) {
 446     return nullptr;
 447   }
 448
 449   virtual UtilityFunction *GetUtilityFunction(const char *text,
 450                                               const char *name) {
 451     return nullptr;
 452   }
 453
 454   virtual PersistentExpressionState *GetPersistentExpressionState() {
 455     return nullptr;
 456   }
 457
 458   virtual CompilerType GetTypeForFormatters(void *type);
 459
 460   virtual LazyBool ShouldPrintAsOneLiner(void *type, ValueObject *valobj);
 461
 462   // Type systems can have types that are placeholder types, which are meant to
 463   // indicate the presence of a type, but offer no actual information about
 464   // said types, and leave the burden of actually figuring type information out
 465   // to dynamic type resolution. For instance a language with a generics
 466   // system, can use placeholder types to indicate "type argument goes here",
 467   // without promising uniqueness of the placeholder, nor attaching any
 468   // actually idenfiable information to said placeholder. This API allows type
 469   // systems to tell LLDB when such a type has been encountered In response,
 470   // the debugger can react by not using this type as a cache entry in any
 471   // type-specific way For instance, LLDB will currently not cache any
 472   // formatters that are discovered on such a type as attributable to the
 473   // meaningless type itself, instead preferring to use the dynamic type
 474   virtual bool IsMeaninglessWithoutDynamicResolution(void *type);
 475
 476 protected:
 477   const LLVMCastKind m_kind; // Support for llvm casting
 478   SymbolFile *m_sym_file;
 479 };
 480
 481 class TypeSystemMap {
 482 public:
 483   TypeSystemMap();
 484   ~TypeSystemMap();
 485
 486   // Clear calls Finalize on all the TypeSystems managed by this map, and then
 487   // empties the map.
 488   void Clear();
 489
 490   // Iterate through all of the type systems that are created. Return true from
 491   // callback to keep iterating, false to stop iterating.
 492   void ForEach(std::function<bool(TypeSystem *)> const &callback);
 493
 494   TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language,
 495                                        Module *module, bool can_create);
 496
 497   TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language,
 498                                        Target *target, bool can_create);
 499
 500 protected:
 501   // This function does not take the map mutex, and should only be called from
 502   // functions that do take the mutex.
 503   void AddToMap(lldb::LanguageType language,
 504                 lldb::TypeSystemSP const &type_system_sp);
 505
 506   typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection;
 507   mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
 508                               ///multi-threaded environments.
 509   collection m_map;
 510   bool m_clear_in_progress;
 511 };
 512
 513 } // namespace lldb_private
 514
 515 #endif // liblldb_TypeSystem_h_