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