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

   1 //===-- ClangASTContext.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_ClangASTContext_h_
  11 #define liblldb_ClangASTContext_h_
  12
  13 // C Includes
  14 #include <stdint.h>
  15
  16 // C++ Includes
  17 #include <functional>
  18 #include <initializer_list>
  19 #include <map>
  20 #include <memory>
  21 #include <set>
  22 #include <string>
  23 #include <utility>
  24 #include <vector>
  25
  26 // Other libraries and framework includes
  27 #include "clang/AST/ASTContext.h"
  28 #include "clang/AST/ExternalASTMerger.h"
  29 #include "clang/AST/TemplateBase.h"
  30 #include "llvm/ADT/SmallVector.h"
  31
  32 // Project includes
  33 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
  34 #include "lldb/Core/ClangForward.h"
  35 #include "lldb/Symbol/CompilerType.h"
  36 #include "lldb/Symbol/TypeSystem.h"
  37 #include "lldb/Utility/ConstString.h"
  38 #include "lldb/lldb-enumerations.h"
  39
  40 class DWARFASTParserClang;
  41 #ifdef LLDB_ENABLE_ALL
  42 class PDBASTParser;
  43 #endif // LLDB_ENABLE_ALL
  44
  45 namespace lldb_private {
  46
  47 class Declaration;
  48
  49 class ClangASTContext : public TypeSystem {
  50 public:
  51   typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);
  52   typedef void (*CompleteObjCInterfaceDeclCallback)(void *baton,
  53                                                     clang::ObjCInterfaceDecl *);
  54
  55   //------------------------------------------------------------------
  56   // llvm casting support
  57   //------------------------------------------------------------------
  58   static bool classof(const TypeSystem *ts) {
  59     return ts->getKind() == TypeSystem::eKindClang;
  60   }
  61
  62   //------------------------------------------------------------------
  63   // Constructors and Destructors
  64   //------------------------------------------------------------------
  65   ClangASTContext(const char *triple = nullptr);
  66
  67   ~ClangASTContext() override;
  68
  69   void Finalize() override;
  70
  71   //------------------------------------------------------------------
  72   // PluginInterface functions
  73   //------------------------------------------------------------------
  74   ConstString GetPluginName() override;
  75
  76   uint32_t GetPluginVersion() override;
  77
  78   static ConstString GetPluginNameStatic();
  79
  80   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
  81                                            Module *module, Target *target);
  82
  83   static void EnumerateSupportedLanguages(
  84       std::set<lldb::LanguageType> &languages_for_types,
  85       std::set<lldb::LanguageType> &languages_for_expressions);
  86
  87   static void Initialize();
  88
  89   static void Terminate();
  90
  91   static ClangASTContext *GetASTContext(clang::ASTContext *ast_ctx);
  92
  93   clang::ASTContext *getASTContext();
  94
  95   void setASTContext(clang::ASTContext *ast_ctx);
  96
  97   clang::Builtin::Context *getBuiltinContext();
  98
  99   clang::IdentifierTable *getIdentifierTable();
 100
 101   clang::LangOptions *getLanguageOptions();
 102
 103   clang::SelectorTable *getSelectorTable();
 104
 105   clang::FileManager *getFileManager();
 106
 107   clang::SourceManager *getSourceManager();
 108
 109   clang::DiagnosticsEngine *getDiagnosticsEngine();
 110
 111   clang::DiagnosticConsumer *getDiagnosticConsumer();
 112
 113   clang::MangleContext *getMangleContext();
 114
 115   std::shared_ptr<clang::TargetOptions> &getTargetOptions();
 116
 117   clang::TargetInfo *getTargetInfo();
 118
 119   void Clear();
 120
 121   const char *GetTargetTriple();
 122
 123   void SetTargetTriple(const char *target_triple);
 124
 125   void SetArchitecture(const ArchSpec &arch);
 126
 127   bool HasExternalSource();
 128
 129   void SetExternalSource(
 130       llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> &ast_source_ap);
 131
 132   void RemoveExternalSource();
 133
 134   bool GetCompleteDecl(clang::Decl *decl) {
 135     return ClangASTContext::GetCompleteDecl(getASTContext(), decl);
 136   }
 137
 138   static void DumpDeclHiearchy(clang::Decl *decl);
 139
 140   static void DumpDeclContextHiearchy(clang::DeclContext *decl_ctx);
 141
 142   static bool DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl);
 143
 144   static bool GetCompleteDecl(clang::ASTContext *ast, clang::Decl *decl);
 145
 146   void SetMetadataAsUserID(const void *object, lldb::user_id_t user_id);
 147
 148   void SetMetadata(const void *object, ClangASTMetadata &meta_data) {
 149     SetMetadata(getASTContext(), object, meta_data);
 150   }
 151
 152   static void SetMetadata(clang::ASTContext *ast, const void *object,
 153                           ClangASTMetadata &meta_data);
 154
 155   ClangASTMetadata *GetMetadata(const void *object) {
 156     return GetMetadata(getASTContext(), object);
 157   }
 158
 159   static ClangASTMetadata *GetMetadata(clang::ASTContext *ast,
 160                                        const void *object);
 161
 162   //------------------------------------------------------------------
 163   // Basic Types
 164   //------------------------------------------------------------------
 165   CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
 166                                                    size_t bit_size) override;
 167
 168   static CompilerType GetBuiltinTypeForEncodingAndBitSize(
 169       clang::ASTContext *ast, lldb::Encoding encoding, uint32_t bit_size);
 170
 171   CompilerType GetBasicType(lldb::BasicType type);
 172
 173   static CompilerType GetBasicType(clang::ASTContext *ast,
 174                                    lldb::BasicType type);
 175
 176   static CompilerType GetBasicType(clang::ASTContext *ast,
 177                                    const ConstString &name);
 178
 179   static lldb::BasicType GetBasicTypeEnumeration(const ConstString &name);
 180
 181   CompilerType GetBuiltinTypeForDWARFEncodingAndBitSize(const char *type_name,
 182                                                         uint32_t dw_ate,
 183                                                         uint32_t bit_size);
 184
 185   CompilerType GetCStringType(bool is_const);
 186
 187   static CompilerType GetUnknownAnyType(clang::ASTContext *ast);
 188
 189   CompilerType GetUnknownAnyType() {
 190     return ClangASTContext::GetUnknownAnyType(getASTContext());
 191   }
 192
 193   static clang::DeclContext *GetDeclContextForType(clang::QualType type);
 194
 195   static clang::DeclContext *GetDeclContextForType(const CompilerType &type);
 196
 197   uint32_t GetPointerByteSize() override;
 198
 199   static clang::DeclContext *GetTranslationUnitDecl(clang::ASTContext *ast);
 200
 201   clang::DeclContext *GetTranslationUnitDecl() {
 202     return GetTranslationUnitDecl(getASTContext());
 203   }
 204
 205   static clang::Decl *CopyDecl(clang::ASTContext *dest_context,
 206                                clang::ASTContext *source_context,
 207                                clang::Decl *source_decl);
 208
 209   static bool AreTypesSame(CompilerType type1, CompilerType type2,
 210                            bool ignore_qualifiers = false);
 211
 212   static CompilerType GetTypeForDecl(clang::NamedDecl *decl);
 213
 214   static CompilerType GetTypeForDecl(clang::TagDecl *decl);
 215
 216   static CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
 217
 218   template <typename RecordDeclType>
 219   CompilerType GetTypeForIdentifier(const ConstString &type_name) {
 220     CompilerType compiler_type;
 221
 222     if (type_name.GetLength()) {
 223       clang::ASTContext *ast = getASTContext();
 224       if (ast) {
 225         clang::IdentifierInfo &myIdent =
 226             ast->Idents.get(type_name.GetCString());
 227         clang::DeclarationName myName =
 228             ast->DeclarationNames.getIdentifier(&myIdent);
 229
 230         clang::DeclContext::lookup_result result =
 231             ast->getTranslationUnitDecl()->lookup(myName);
 232
 233         if (!result.empty()) {
 234           clang::NamedDecl *named_decl = result[0];
 235           if (const RecordDeclType *record_decl =
 236                   llvm::dyn_cast<RecordDeclType>(named_decl))
 237             compiler_type.SetCompilerType(
 238                 ast, clang::QualType(record_decl->getTypeForDecl(), 0));
 239         }
 240       }
 241     }
 242
 243     return compiler_type;
 244   }
 245
 246   CompilerType CreateStructForIdentifier(
 247       const ConstString &type_name,
 248       const std::initializer_list<std::pair<const char *, CompilerType>>
 249           &type_fields,
 250       bool packed = false);
 251
 252   CompilerType GetOrCreateStructForIdentifier(
 253       const ConstString &type_name,
 254       const std::initializer_list<std::pair<const char *, CompilerType>>
 255           &type_fields,
 256       bool packed = false);
 257
 258   //------------------------------------------------------------------
 259   // Structure, Unions, Classes
 260   //------------------------------------------------------------------
 261
 262   static clang::AccessSpecifier
 263   ConvertAccessTypeToAccessSpecifier(lldb::AccessType access);
 264
 265   static clang::AccessSpecifier
 266   UnifyAccessSpecifiers(clang::AccessSpecifier lhs, clang::AccessSpecifier rhs);
 267
 268   static uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl,
 269                                     bool omit_empty_base_classes);
 270
 271   CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
 272                                 lldb::AccessType access_type, const char *name,
 273                                 int kind, lldb::LanguageType language,
 274                                 ClangASTMetadata *metadata = nullptr);
 275
 276   class TemplateParameterInfos {
 277   public:
 278     bool IsValid() const {
 279       if (args.empty())
 280         return false;
 281       return args.size() == names.size() &&
 282         ((bool)pack_name == (bool)packed_args) &&
 283         (!packed_args || !packed_args->packed_args);
 284     }
 285
 286     llvm::SmallVector<const char *, 2> names;
 287     llvm::SmallVector<clang::TemplateArgument, 2> args;
 288
 289     const char * pack_name = nullptr;
 290     std::unique_ptr<TemplateParameterInfos> packed_args;
 291   };
 292
 293   clang::FunctionTemplateDecl *
 294   CreateFunctionTemplateDecl(clang::DeclContext *decl_ctx,
 295                              clang::FunctionDecl *func_decl, const char *name,
 296                              const TemplateParameterInfos &infos);
 297
 298   void CreateFunctionTemplateSpecializationInfo(
 299       clang::FunctionDecl *func_decl, clang::FunctionTemplateDecl *Template,
 300       const TemplateParameterInfos &infos);
 301
 302   clang::ClassTemplateDecl *
 303   CreateClassTemplateDecl(clang::DeclContext *decl_ctx,
 304                           lldb::AccessType access_type, const char *class_name,
 305                           int kind, const TemplateParameterInfos &infos);
 306
 307   clang::ClassTemplateSpecializationDecl *CreateClassTemplateSpecializationDecl(
 308       clang::DeclContext *decl_ctx,
 309       clang::ClassTemplateDecl *class_template_decl, int kind,
 310       const TemplateParameterInfos &infos);
 311
 312   CompilerType
 313   CreateClassTemplateSpecializationType(clang::ClassTemplateSpecializationDecl *
 314                                             class_template_specialization_decl);
 315
 316   static clang::DeclContext *
 317   GetAsDeclContext(clang::CXXMethodDecl *cxx_method_decl);
 318
 319   static clang::DeclContext *
 320   GetAsDeclContext(clang::ObjCMethodDecl *objc_method_decl);
 321
 322   static bool CheckOverloadedOperatorKindParameterCount(
 323       bool is_method, clang::OverloadedOperatorKind op_kind,
 324       uint32_t num_params);
 325
 326   bool FieldIsBitfield(clang::FieldDecl *field, uint32_t &bitfield_bit_size);
 327
 328   static bool FieldIsBitfield(clang::ASTContext *ast, clang::FieldDecl *field,
 329                               uint32_t &bitfield_bit_size);
 330
 331   static bool RecordHasFields(const clang::RecordDecl *record_decl);
 332
 333   CompilerType CreateObjCClass(const char *name, clang::DeclContext *decl_ctx,
 334                                bool isForwardDecl, bool isInternal,
 335                                ClangASTMetadata *metadata = nullptr);
 336
 337   bool SetTagTypeKind(clang::QualType type, int kind) const;
 338
 339   bool SetDefaultAccessForRecordFields(clang::RecordDecl *record_decl,
 340                                        int default_accessibility,
 341                                        int *assigned_accessibilities,
 342                                        size_t num_assigned_accessibilities);
 343
 344   // Returns a mask containing bits from the ClangASTContext::eTypeXXX
 345   // enumerations
 346
 347   //------------------------------------------------------------------
 348   // Namespace Declarations
 349   //------------------------------------------------------------------
 350
 351   clang::NamespaceDecl *
 352   GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx);
 353
 354   static clang::NamespaceDecl *
 355   GetUniqueNamespaceDeclaration(clang::ASTContext *ast, const char *name,
 356                                 clang::DeclContext *decl_ctx);
 357
 358   //------------------------------------------------------------------
 359   // Function Types
 360   //------------------------------------------------------------------
 361
 362   clang::FunctionDecl *
 363   CreateFunctionDeclaration(clang::DeclContext *decl_ctx, const char *name,
 364                             const CompilerType &function_Type, int storage,
 365                             bool is_inline);
 366
 367   static CompilerType CreateFunctionType(clang::ASTContext *ast,
 368                                          const CompilerType &result_type,
 369                                          const CompilerType *args,
 370                                          unsigned num_args, bool is_variadic,
 371                                          unsigned type_quals);
 372
 373   CompilerType CreateFunctionType(const CompilerType &result_type,
 374                                   const CompilerType *args, unsigned num_args,
 375                                   bool is_variadic, unsigned type_quals) {
 376     return ClangASTContext::CreateFunctionType(
 377         getASTContext(), result_type, args, num_args, is_variadic, type_quals);
 378   }
 379
 380   clang::ParmVarDecl *CreateParameterDeclaration(const char *name,
 381                                                  const CompilerType &param_type,
 382                                                  int storage);
 383
 384   void SetFunctionParameters(clang::FunctionDecl *function_decl,
 385                              clang::ParmVarDecl **params, unsigned num_params);
 386
 387   CompilerType CreateBlockPointerType(const CompilerType &function_type);
 388
 389   //------------------------------------------------------------------
 390   // Array Types
 391   //------------------------------------------------------------------
 392
 393   CompilerType CreateArrayType(const CompilerType &element_type,
 394                                size_t element_count, bool is_vector);
 395
 396   //------------------------------------------------------------------
 397   // Enumeration Types
 398   //------------------------------------------------------------------
 399   CompilerType CreateEnumerationType(const char *name,
 400                                      clang::DeclContext *decl_ctx,
 401                                      const Declaration &decl,
 402                                      const CompilerType &integer_qual_type,
 403                                      bool is_scoped);
 404
 405   //------------------------------------------------------------------
 406   // Integer type functions
 407   //------------------------------------------------------------------
 408
 409   static CompilerType GetIntTypeFromBitSize(clang::ASTContext *ast,
 410                                             size_t bit_size, bool is_signed);
 411
 412   CompilerType GetPointerSizedIntType(bool is_signed) {
 413     return GetPointerSizedIntType(getASTContext(), is_signed);
 414   }
 415
 416   static CompilerType GetPointerSizedIntType(clang::ASTContext *ast,
 417                                              bool is_signed);
 418
 419   //------------------------------------------------------------------
 420   // Floating point functions
 421   //------------------------------------------------------------------
 422
 423   static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
 424                                               size_t bit_size);
 425
 426   //------------------------------------------------------------------
 427   // TypeSystem methods
 428   //------------------------------------------------------------------
 429   DWARFASTParser *GetDWARFParser() override;
 430 #ifdef LLDB_ENABLE_ALL
 431   PDBASTParser *GetPDBParser();
 432 #endif // LLDB_ENABLE_ALL
 433
 434   //------------------------------------------------------------------
 435   // ClangASTContext callbacks for external source lookups.
 436   //------------------------------------------------------------------
 437   static void CompleteTagDecl(void *baton, clang::TagDecl *);
 438
 439   static void CompleteObjCInterfaceDecl(void *baton,
 440                                         clang::ObjCInterfaceDecl *);
 441
 442   static bool LayoutRecordType(
 443       void *baton, const clang::RecordDecl *record_decl, uint64_t &size,
 444       uint64_t &alignment,
 445       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
 446       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
 447           &base_offsets,
 448       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
 449           &vbase_offsets);
 450
 451   //----------------------------------------------------------------------
 452   // CompilerDecl override functions
 453   //----------------------------------------------------------------------
 454   ConstString DeclGetName(void *opaque_decl) override;
 455
 456   ConstString DeclGetMangledName(void *opaque_decl) override;
 457
 458   CompilerDeclContext DeclGetDeclContext(void *opaque_decl) override;
 459
 460   CompilerType DeclGetFunctionReturnType(void *opaque_decl) override;
 461
 462   size_t DeclGetFunctionNumArguments(void *opaque_decl) override;
 463
 464   CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
 465                                            size_t arg_idx) override;
 466
 467   //----------------------------------------------------------------------
 468   // CompilerDeclContext override functions
 469   //----------------------------------------------------------------------
 470
 471   std::vector<CompilerDecl>
 472   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
 473                             const bool ignore_using_decls) override;
 474
 475   bool DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) override;
 476
 477   ConstString DeclContextGetName(void *opaque_decl_ctx) override;
 478
 479   ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override;
 480
 481   bool DeclContextIsClassMethod(void *opaque_decl_ctx,
 482                                 lldb::LanguageType *language_ptr,
 483                                 bool *is_instance_method_ptr,
 484                                 ConstString *language_object_name_ptr) override;
 485
 486   //----------------------------------------------------------------------
 487   // Clang specific clang::DeclContext functions
 488   //----------------------------------------------------------------------
 489
 490   static clang::DeclContext *
 491   DeclContextGetAsDeclContext(const CompilerDeclContext &dc);
 492
 493   static clang::ObjCMethodDecl *
 494   DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc);
 495
 496   static clang::CXXMethodDecl *
 497   DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc);
 498
 499   static clang::FunctionDecl *
 500   DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc);
 501
 502   static clang::NamespaceDecl *
 503   DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc);
 504
 505   static ClangASTMetadata *DeclContextGetMetaData(const CompilerDeclContext &dc,
 506                                                   const void *object);
 507
 508   static clang::ASTContext *
 509   DeclContextGetClangASTContext(const CompilerDeclContext &dc);
 510
 511   //----------------------------------------------------------------------
 512   // Tests
 513   //----------------------------------------------------------------------
 514
 515   bool IsArrayType(lldb::opaque_compiler_type_t type,
 516                    CompilerType *element_type, uint64_t *size,
 517                    bool *is_incomplete) override;
 518
 519   bool IsVectorType(lldb::opaque_compiler_type_t type,
 520                     CompilerType *element_type, uint64_t *size) override;
 521
 522   bool IsAggregateType(lldb::opaque_compiler_type_t type) override;
 523
 524   bool IsAnonymousType(lldb::opaque_compiler_type_t type) override;
 525
 526   bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;
 527
 528   bool IsCharType(lldb::opaque_compiler_type_t type) override;
 529
 530   bool IsCompleteType(lldb::opaque_compiler_type_t type) override;
 531
 532   bool IsConst(lldb::opaque_compiler_type_t type) override;
 533
 534   bool IsCStringType(lldb::opaque_compiler_type_t type,
 535                      uint32_t &length) override;
 536
 537   static bool IsCXXClassType(const CompilerType &type);
 538
 539   bool IsDefined(lldb::opaque_compiler_type_t type) override;
 540
 541   bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
 542                            bool &is_complex) override;
 543
 544   bool IsFunctionType(lldb::opaque_compiler_type_t type,
 545                       bool *is_variadic_ptr) override;
 546
 547   uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
 548                                   CompilerType *base_type_ptr) override;
 549
 550   size_t
 551   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override;
 552
 553   CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
 554                                           const size_t index) override;
 555
 556   bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override;
 557
 558   bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
 559                           CompilerType *function_pointer_type_ptr) override;
 560
 561   bool IsIntegerType(lldb::opaque_compiler_type_t type,
 562                      bool &is_signed) override;
 563
 564   bool IsEnumerationType(lldb::opaque_compiler_type_t type,
 565                          bool &is_signed) override;
 566
 567   static bool IsObjCClassType(const CompilerType &type);
 568
 569   static bool IsObjCClassTypeAndHasIVars(const CompilerType &type,
 570                                          bool check_superclass);
 571
 572   static bool IsObjCObjectOrInterfaceType(const CompilerType &type);
 573
 574   static bool IsObjCObjectPointerType(const CompilerType &type,
 575                                       CompilerType *target_type = nullptr);
 576
 577   bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override;
 578
 579   static bool IsClassType(lldb::opaque_compiler_type_t type);
 580
 581   static bool IsEnumType(lldb::opaque_compiler_type_t type);
 582
 583   bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
 584                              CompilerType *target_type, // Can pass nullptr
 585                              bool check_cplusplus, bool check_objc) override;
 586
 587   bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override;
 588
 589   bool IsPointerType(lldb::opaque_compiler_type_t type,
 590                      CompilerType *pointee_type) override;
 591
 592   bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
 593                                 CompilerType *pointee_type) override;
 594
 595   bool IsReferenceType(lldb::opaque_compiler_type_t type,
 596                        CompilerType *pointee_type, bool *is_rvalue) override;
 597
 598   bool IsScalarType(lldb::opaque_compiler_type_t type) override;
 599
 600   bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
 601
 602   bool IsVoidType(lldb::opaque_compiler_type_t type) override;
 603
 604   bool SupportsLanguage(lldb::LanguageType language) override;
 605
 606   static bool GetCXXClassName(const CompilerType &type,
 607                               std::string &class_name);
 608
 609   static bool GetObjCClassName(const CompilerType &type,
 610                                std::string &class_name);
 611
 612   //----------------------------------------------------------------------
 613   // Type Completion
 614   //----------------------------------------------------------------------
 615
 616   bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
 617
 618   //----------------------------------------------------------------------
 619   // Accessors
 620   //----------------------------------------------------------------------
 621
 622   ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;
 623
 624   uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type,
 625                        CompilerType *pointee_or_element_compiler_type) override;
 626
 627   lldb::LanguageType
 628   GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
 629
 630   lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
 631
 632   unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
 633
 634   //----------------------------------------------------------------------
 635   // Creating related types
 636   //----------------------------------------------------------------------
 637
 638   // Using the current type, create a new typedef to that type using
 639   // "typedef_name"
 640   // as the name and "decl_ctx" as the decl context.
 641   static CompilerType
 642   CreateTypedefType(const CompilerType &type, const char *typedef_name,
 643                     const CompilerDeclContext &compiler_decl_ctx);
 644
 645   CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type,
 646                                    uint64_t *stride) override;
 647
 648   CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
 649                             uint64_t size) override;
 650
 651   CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
 652
 653   CompilerType
 654   GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;
 655
 656   // Returns -1 if this isn't a function of if the function doesn't have a
 657   // prototype
 658   // Returns a value >= 0 if there is a prototype.
 659   int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
 660
 661   CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
 662                                               size_t idx) override;
 663
 664   CompilerType
 665   GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;
 666
 667   size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override;
 668
 669   TypeMemberFunctionImpl
 670   GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
 671                            size_t idx) override;
 672
 673   CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;
 674
 675   CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;
 676
 677   CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
 678
 679   CompilerType
 680   GetLValueReferenceType(lldb::opaque_compiler_type_t type) override;
 681
 682   CompilerType
 683   GetRValueReferenceType(lldb::opaque_compiler_type_t type) override;
 684
 685   CompilerType AddConstModifier(lldb::opaque_compiler_type_t type) override;
 686
 687   CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type) override;
 688
 689   CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type) override;
 690
 691   CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
 692                              const char *name,
 693                              const CompilerDeclContext &decl_ctx) override;
 694
 695   // If the current object represents a typedef type, get the underlying type
 696   CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
 697
 698   //----------------------------------------------------------------------
 699   // Create related types using the current type's AST
 700   //----------------------------------------------------------------------
 701   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
 702
 703   //----------------------------------------------------------------------
 704   // Exploring the type
 705   //----------------------------------------------------------------------
 706
 707   uint64_t GetByteSize(lldb::opaque_compiler_type_t type,
 708                        ExecutionContextScope *exe_scope) {
 709     return (GetBitSize(type, exe_scope) + 7) / 8;
 710   }
 711
 712   uint64_t GetBitSize(lldb::opaque_compiler_type_t type,
 713                       ExecutionContextScope *exe_scope) override;
 714
 715   lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
 716                              uint64_t &count) override;
 717
 718   lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 719
 720   size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;
 721
 722   uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
 723                           bool omit_empty_base_classes) override;
 724
 725   CompilerType GetBuiltinTypeByName(const ConstString &name) override;
 726
 727   lldb::BasicType
 728   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
 729
 730   static lldb::BasicType
 731   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type,
 732                           const ConstString &name);
 733
 734   void ForEachEnumerator(
 735       lldb::opaque_compiler_type_t type,
 736       std::function<bool(const CompilerType &integer_type,
 737                          const ConstString &name,
 738                          const llvm::APSInt &value)> const &callback) override;
 739
 740   uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
 741
 742   CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
 743                                std::string &name, uint64_t *bit_offset_ptr,
 744                                uint32_t *bitfield_bit_size_ptr,
 745                                bool *is_bitfield_ptr) override;
 746
 747   uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override;
 748
 749   uint32_t GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override;
 750
 751   CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type,
 752                                          size_t idx,
 753                                          uint32_t *bit_offset_ptr) override;
 754
 755   CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type,
 756                                           size_t idx,
 757                                           uint32_t *bit_offset_ptr) override;
 758
 759   static uint32_t GetNumPointeeChildren(clang::QualType type);
 760
 761   CompilerType GetChildCompilerTypeAtIndex(
 762       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
 763       bool transparent_pointers, bool omit_empty_base_classes,
 764       bool ignore_array_bounds, std::string &child_name,
 765       uint32_t &child_byte_size, int32_t &child_byte_offset,
 766       uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
 767       bool &child_is_base_class, bool &child_is_deref_of_parent,
 768       ValueObject *valobj, uint64_t &language_flags) override;
 769
 770   // Lookup a child given a name. This function will match base class names
 771   // and member member names in "clang_type" only, not descendants.
 772   uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
 773                                    const char *name,
 774                                    bool omit_empty_base_classes) override;
 775
 776   // Lookup a child member given a name. This function will match member names
 777   // only and will descend into "clang_type" children in search for the first
 778   // member in this class, or any base class that matches "name".
 779   // TODO: Return all matches for a given name by returning a
 780   // vector<vector<uint32_t>>
 781   // so we catch all names that match a given child name, not just the first.
 782   size_t
 783   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
 784                                 const char *name, bool omit_empty_base_classes,
 785                                 std::vector<uint32_t> &child_indexes) override;
 786
 787   size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override;
 788
 789   lldb::TemplateArgumentKind
 790   GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
 791                           size_t idx) override;
 792   CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
 793                                        size_t idx) override;
 794   llvm::Optional<CompilerType::IntegralTemplateArgument>
 795   GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
 796                               size_t idx) override;
 797
 798   CompilerType GetTypeForFormatters(void *type) override;
 799
 800 #define LLDB_INVALID_DECL_LEVEL UINT32_MAX
 801   // LLDB_INVALID_DECL_LEVEL is returned by CountDeclLevels if
 802   // child_decl_ctx could not be found in decl_ctx.
 803   uint32_t CountDeclLevels(clang::DeclContext *frame_decl_ctx,
 804                            clang::DeclContext *child_decl_ctx,
 805                            ConstString *child_name = nullptr,
 806                            CompilerType *child_type = nullptr);
 807
 808   //----------------------------------------------------------------------
 809   // Modifying RecordType
 810   //----------------------------------------------------------------------
 811   static clang::FieldDecl *AddFieldToRecordType(const CompilerType &type,
 812                                                 const char *name,
 813                                                 const CompilerType &field_type,
 814                                                 lldb::AccessType access,
 815                                                 uint32_t bitfield_bit_size);
 816
 817   static void BuildIndirectFields(const CompilerType &type);
 818
 819   static void SetIsPacked(const CompilerType &type);
 820
 821   static clang::VarDecl *AddVariableToRecordType(const CompilerType &type,
 822                                                  const char *name,
 823                                                  const CompilerType &var_type,
 824                                                  lldb::AccessType access);
 825
 826   clang::CXXMethodDecl *
 827   AddMethodToCXXRecordType(lldb::opaque_compiler_type_t type, const char *name,
 828                            const CompilerType &method_type,
 829                            lldb::AccessType access, bool is_virtual,
 830                            bool is_static, bool is_inline, bool is_explicit,
 831                            bool is_attr_used, bool is_artificial);
 832
 833   // C++ Base Classes
 834   clang::CXXBaseSpecifier *
 835   CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
 836                            lldb::AccessType access, bool is_virtual,
 837                            bool base_of_class);
 838
 839   static void DeleteBaseClassSpecifiers(clang::CXXBaseSpecifier **base_classes,
 840                                         unsigned num_base_classes);
 841
 842   bool
 843   SetBaseClassesForClassType(lldb::opaque_compiler_type_t type,
 844                              clang::CXXBaseSpecifier const *const *base_classes,
 845                              unsigned num_base_classes);
 846
 847   static bool SetObjCSuperClass(const CompilerType &type,
 848                                 const CompilerType &superclass_compiler_type);
 849
 850   static bool AddObjCClassProperty(const CompilerType &type,
 851                                    const char *property_name,
 852                                    const CompilerType &property_compiler_type,
 853                                    clang::ObjCIvarDecl *ivar_decl,
 854                                    const char *property_setter_name,
 855                                    const char *property_getter_name,
 856                                    uint32_t property_attributes,
 857                                    ClangASTMetadata *metadata);
 858
 859   static clang::ObjCMethodDecl *AddMethodToObjCObjectType(
 860       const CompilerType &type,
 861       const char *name, // the full symbol name as seen in the symbol table
 862                         // (lldb::opaque_compiler_type_t type, "-[NString
 863                         // stringWithCString:]")
 864       const CompilerType &method_compiler_type, lldb::AccessType access,
 865       bool is_artificial, bool is_variadic);
 866
 867   static bool SetHasExternalStorage(lldb::opaque_compiler_type_t type,
 868                                     bool has_extern);
 869
 870   static bool GetHasExternalStorage(const CompilerType &type);
 871   //------------------------------------------------------------------
 872   // Tag Declarations
 873   //------------------------------------------------------------------
 874   static bool StartTagDeclarationDefinition(const CompilerType &type);
 875
 876   static bool CompleteTagDeclarationDefinition(const CompilerType &type);
 877
 878   //----------------------------------------------------------------------
 879   // Modifying Enumeration types
 880   //----------------------------------------------------------------------
 881   bool AddEnumerationValueToEnumerationType(
 882       lldb::opaque_compiler_type_t type,
 883       const CompilerType &enumerator_qual_type, const Declaration &decl,
 884       const char *name, int64_t enum_value, uint32_t enum_value_bit_size);
 885
 886   CompilerType GetEnumerationIntegerType(lldb::opaque_compiler_type_t type);
 887
 888   //------------------------------------------------------------------
 889   // Pointers & References
 890   //------------------------------------------------------------------
 891
 892   // Call this function using the class type when you want to make a
 893   // member pointer type to pointee_type.
 894   static CompilerType CreateMemberPointerType(const CompilerType &type,
 895                                               const CompilerType &pointee_type);
 896
 897   // Converts "s" to a floating point value and place resulting floating
 898   // point bytes in the "dst" buffer.
 899   size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
 900                                    const char *s, uint8_t *dst,
 901                                    size_t dst_size) override;
 902
 903   //----------------------------------------------------------------------
 904   // Dumping types
 905   //----------------------------------------------------------------------
 906   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
 907                  Stream *s, lldb::Format format, const DataExtractor &data,
 908                  lldb::offset_t data_offset, size_t data_byte_size,
 909                  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
 910                  bool show_types, bool show_summary, bool verbose,
 911                  uint32_t depth) override;
 912
 913   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
 914                      lldb::Format format, const DataExtractor &data,
 915                      lldb::offset_t data_offset, size_t data_byte_size,
 916                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
 917                      ExecutionContextScope *exe_scope) override;
 918
 919   void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
 920                    Stream *s, const DataExtractor &data,
 921                    lldb::offset_t data_offset, size_t data_byte_size) override;
 922
 923   void DumpTypeDescription(
 924       lldb::opaque_compiler_type_t type) override; // Dump to stdout
 925
 926   void DumpTypeDescription(lldb::opaque_compiler_type_t type,
 927                            Stream *s) override;
 928
 929   static void DumpTypeName(const CompilerType &type);
 930
 931   static clang::EnumDecl *GetAsEnumDecl(const CompilerType &type);
 932
 933   static clang::RecordDecl *GetAsRecordDecl(const CompilerType &type);
 934
 935   static clang::TagDecl *GetAsTagDecl(const CompilerType &type);
 936
 937   clang::CXXRecordDecl *GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type);
 938
 939   static clang::ObjCInterfaceDecl *
 940   GetAsObjCInterfaceDecl(const CompilerType &type);
 941
 942   clang::ClassTemplateDecl *ParseClassTemplateDecl(
 943       clang::DeclContext *decl_ctx, lldb::AccessType access_type,
 944       const char *parent_name, int tag_decl_kind,
 945       const ClangASTContext::TemplateParameterInfos &template_param_infos);
 946
 947   clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx);
 948
 949   clang::UsingDirectiveDecl *
 950   CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
 951                                   clang::NamespaceDecl *ns_decl);
 952
 953   clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
 954                                            clang::NamedDecl *target);
 955
 956   clang::VarDecl *CreateVariableDeclaration(clang::DeclContext *decl_context,
 957                                             const char *name,
 958                                             clang::QualType type);
 959
 960   static lldb::opaque_compiler_type_t
 961   GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType basic_type);
 962
 963   static clang::QualType GetQualType(lldb::opaque_compiler_type_t type) {
 964     if (type)
 965       return clang::QualType::getFromOpaquePtr(type);
 966     return clang::QualType();
 967   }
 968
 969   static clang::QualType
 970   GetCanonicalQualType(lldb::opaque_compiler_type_t type) {
 971     if (type)
 972       return clang::QualType::getFromOpaquePtr(type).getCanonicalType();
 973     return clang::QualType();
 974   }
 975
 976   clang::DeclarationName
 977   GetDeclarationName(const char *name, const CompilerType &function_clang_type);
 978
 979   virtual const clang::ExternalASTMerger::OriginMap &GetOriginMap() {
 980     return m_origins;
 981   }
 982 protected:
 983   const clang::ClassTemplateSpecializationDecl *
 984   GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
 985
 986   //------------------------------------------------------------------
 987   // Classes that inherit from ClangASTContext can see and modify these
 988   //------------------------------------------------------------------
 989   // clang-format off
 990     std::string                                     m_target_triple;
 991     std::unique_ptr<clang::ASTContext>              m_ast_ap;
 992     std::unique_ptr<clang::LangOptions>             m_language_options_ap;
 993     std::unique_ptr<clang::FileManager>             m_file_manager_ap;
 994     std::unique_ptr<clang::FileSystemOptions>       m_file_system_options_ap;
 995     std::unique_ptr<clang::SourceManager>           m_source_manager_ap;
 996     std::unique_ptr<clang::DiagnosticsEngine>       m_diagnostics_engine_ap;
 997     std::unique_ptr<clang::DiagnosticConsumer>      m_diagnostic_consumer_ap;
 998     std::shared_ptr<clang::TargetOptions>           m_target_options_rp;
 999     std::unique_ptr<clang::TargetInfo>              m_target_info_ap;
1000     std::unique_ptr<clang::IdentifierTable>         m_identifier_table_ap;
1001     std::unique_ptr<clang::SelectorTable>           m_selector_table_ap;
1002     std::unique_ptr<clang::Builtin::Context>        m_builtins_ap;
1003     std::unique_ptr<DWARFASTParserClang>            m_dwarf_ast_parser_ap;
1004 #ifdef LLDB_ENABLE_ALL
1005     std::unique_ptr<PDBASTParser>                   m_pdb_ast_parser_ap;
1006 #endif // LLDB_ENABLE_ALL
1007     std::unique_ptr<ClangASTSource>                 m_scratch_ast_source_ap;
1008     std::unique_ptr<clang::MangleContext>           m_mangle_ctx_ap;
1009     CompleteTagDeclCallback                         m_callback_tag_decl;
1010     CompleteObjCInterfaceDeclCallback               m_callback_objc_decl;
1011     void *                                          m_callback_baton;
1012     clang::ExternalASTMerger::OriginMap             m_origins;
1013     uint32_t                                        m_pointer_byte_size;
1014     bool                                            m_ast_owned;
1015     bool                                            m_can_evaluate_expressions;
1016   // clang-format on
1017 private:
1018   //------------------------------------------------------------------
1019   // For ClangASTContext only
1020   //------------------------------------------------------------------
1021   ClangASTContext(const ClangASTContext &);
1022   const ClangASTContext &operator=(const ClangASTContext &);
1023 };
1024
1025 class ClangASTContextForExpressions : public ClangASTContext {
1026 public:
1027   ClangASTContextForExpressions(Target &target);
1028
1029   ~ClangASTContextForExpressions() override = default;
1030
1031   UserExpression *
1032   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
1033                     lldb::LanguageType language,
1034                     Expression::ResultType desired_type,
1035                     const EvaluateExpressionOptions &options) override;
1036
1037   FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
1038                                     const Address &function_address,
1039                                     const ValueList &arg_value_list,
1040                                     const char *name) override;
1041
1042   UtilityFunction *GetUtilityFunction(const char *text,
1043                                       const char *name) override;
1044
1045   PersistentExpressionState *GetPersistentExpressionState() override;
1046
1047   clang::ExternalASTMerger &GetMergerUnchecked();
1048
1049   const clang::ExternalASTMerger::OriginMap &GetOriginMap() override {
1050     return GetMergerUnchecked().GetOrigins();
1051   }
1052 private:
1053   lldb::TargetWP m_target_wp;
1054   lldb::ClangPersistentVariablesUP m_persistent_variables; ///< These are the
1055                                                            ///persistent
1056                                                            ///variables
1057                                                            ///associated with
1058                                                            ///this process for
1059                                                            ///the expression
1060                                                            ///parser.
1061 };
1062
1063 } // namespace lldb_private
1064
1065 #endif // liblldb_ClangASTContext_h_