LLDB  mainline
TypeSystemClang.h
Go to the documentation of this file.
1 //===-- TypeSystemClang.h ---------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_TYPESYSTEMCLANG_H
10 #define LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_TYPESYSTEMCLANG_H
11 
12 #include <cstdint>
13 
14 #include <functional>
15 #include <initializer_list>
16 #include <map>
17 #include <memory>
18 #include <set>
19 #include <string>
20 #include <utility>
21 #include <vector>
22 
23 #include "clang/AST/ASTContext.h"
24 #include "clang/AST/ASTFwd.h"
25 #include "clang/AST/TemplateBase.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "llvm/ADT/APSInt.h"
28 #include "llvm/ADT/SmallVector.h"
29 
33 #include "lldb/Symbol/TypeSystem.h"
34 #include "lldb/Target/Target.h"
36 #include "lldb/Utility/Flags.h"
37 #include "lldb/Utility/Log.h"
38 #include "lldb/lldb-enumerations.h"
39 
41 class PDBASTParser;
42 
43 namespace clang {
44 class FileManager;
45 class HeaderSearch;
46 class ModuleMap;
47 } // namespace clang
48 
49 namespace lldb_private {
50 
51 class ClangASTMetadata;
52 class ClangASTSource;
53 class Declaration;
54 
55 /// A Clang module ID.
57  unsigned m_id = 0;
58 
59 public:
60  OptionalClangModuleID() = default;
61  explicit OptionalClangModuleID(unsigned id) : m_id(id) {}
62  bool HasValue() const { return m_id != 0; }
63  unsigned GetValue() const { return m_id; }
64 };
65 
66 /// The implementation of lldb::Type's m_payload field for TypeSystemClang.
68  /// The Layout is as follows:
69  /// \verbatim
70  /// bit 0..30 ... Owning Module ID.
71  /// bit 31 ...... IsCompleteObjCClass.
72  /// \endverbatim
74 
75 public:
76  TypePayloadClang() = default;
77  explicit TypePayloadClang(OptionalClangModuleID owning_module,
78  bool is_complete_objc_class = false);
79  explicit TypePayloadClang(uint32_t opaque_payload) : m_payload(opaque_payload) {}
80  operator Type::Payload() { return m_payload; }
81 
82  static constexpr unsigned ObjCClassBit = 1 << 31;
84  void SetIsCompleteObjCClass(bool is_complete_objc_class) {
85  m_payload = is_complete_objc_class ? Flags(m_payload).Set(ObjCClassBit)
87  }
90  }
92  /// \}
93 };
94 
95 /// A TypeSystem implementation based on Clang.
96 ///
97 /// This class uses a single clang::ASTContext as the backend for storing
98 /// its types and declarations. Every clang::ASTContext should also just have
99 /// a single associated TypeSystemClang instance that manages it.
100 ///
101 /// The clang::ASTContext instance can either be created by TypeSystemClang
102 /// itself or it can adopt an existing clang::ASTContext (for example, when
103 /// it is necessary to provide a TypeSystem interface for an existing
104 /// clang::ASTContext that was created by clang::CompilerInstance).
105 class TypeSystemClang : public TypeSystem {
106  // LLVM RTTI support
107  static char ID;
108 
109 public:
110  typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);
111  typedef void (*CompleteObjCInterfaceDeclCallback)(void *baton,
112  clang::ObjCInterfaceDecl *);
113 
114  // llvm casting support
115  bool isA(const void *ClassID) const override { return ClassID == &ID; }
116  static bool classof(const TypeSystem *ts) { return ts->isA(&ID); }
117 
118  /// Constructs a TypeSystemClang with an ASTContext using the given triple.
119  ///
120  /// \param name The name for the TypeSystemClang (for logging purposes)
121  /// \param triple The llvm::Triple used for the ASTContext. The triple defines
122  /// certain characteristics of the ASTContext and its types
123  /// (e.g., whether certain primitive types exist or what their
124  /// signedness is).
125  explicit TypeSystemClang(llvm::StringRef name, llvm::Triple triple);
126 
127  /// Constructs a TypeSystemClang that uses an existing ASTContext internally.
128  /// Useful when having an existing ASTContext created by Clang.
129  ///
130  /// \param name The name for the TypeSystemClang (for logging purposes)
131  /// \param existing_ctxt An existing ASTContext.
132  explicit TypeSystemClang(llvm::StringRef name,
133  clang::ASTContext &existing_ctxt);
134 
135  ~TypeSystemClang() override;
136 
137  void Finalize() override;
138 
139  // PluginInterface functions
140  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
141 
142  static llvm::StringRef GetPluginNameStatic() { return "clang"; }
143 
144  static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
145  Module *module, Target *target);
146 
149 
150  static void Initialize();
151 
152  static void Terminate();
153 
154  static TypeSystemClang *GetASTContext(clang::ASTContext *ast_ctx);
155 
156  /// Returns the display name of this TypeSystemClang that indicates what
157  /// purpose it serves in LLDB. Used for example in logs.
158  llvm::StringRef getDisplayName() const { return m_display_name; }
159 
160  /// Returns the clang::ASTContext instance managed by this TypeSystemClang.
161  clang::ASTContext &getASTContext();
162 
163  clang::MangleContext *getMangleContext();
164 
165  std::shared_ptr<clang::TargetOptions> &getTargetOptions();
166 
167  clang::TargetInfo *getTargetInfo();
168 
169  void setSema(clang::Sema *s);
170  clang::Sema *getSema() { return m_sema; }
171 
172  const char *GetTargetTriple();
173 
174  void SetExternalSource(
175  llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> &ast_source_up);
176 
177  bool GetCompleteDecl(clang::Decl *decl) {
179  }
180 
181  static void DumpDeclHiearchy(clang::Decl *decl);
182 
183  static void DumpDeclContextHiearchy(clang::DeclContext *decl_ctx);
184 
185  static bool DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl);
186 
187  static bool GetCompleteDecl(clang::ASTContext *ast, clang::Decl *decl);
188 
189  void SetMetadataAsUserID(const clang::Decl *decl, lldb::user_id_t user_id);
190  void SetMetadataAsUserID(const clang::Type *type, lldb::user_id_t user_id);
191 
192  void SetMetadata(const clang::Decl *object, ClangASTMetadata &meta_data);
193 
194  void SetMetadata(const clang::Type *object, ClangASTMetadata &meta_data);
195  ClangASTMetadata *GetMetadata(const clang::Decl *object);
196  ClangASTMetadata *GetMetadata(const clang::Type *object);
197 
198  void SetCXXRecordDeclAccess(const clang::CXXRecordDecl *object,
199  clang::AccessSpecifier access);
200  clang::AccessSpecifier
201  GetCXXRecordDeclAccess(const clang::CXXRecordDecl *object);
202 
203  // Basic Types
205  size_t bit_size) override;
206 
208 
210 
212  GetBuiltinTypeForDWARFEncodingAndBitSize(llvm::StringRef type_name,
213  uint32_t dw_ate, uint32_t bit_size);
214 
215  CompilerType GetCStringType(bool is_const);
216 
217  static clang::DeclContext *GetDeclContextForType(clang::QualType type);
218 
219  static clang::DeclContext *GetDeclContextForType(const CompilerType &type);
220 
221  uint32_t GetPointerByteSize() override;
222 
223  clang::TranslationUnitDecl *GetTranslationUnitDecl() {
224  return getASTContext().getTranslationUnitDecl();
225  }
226 
227  static bool AreTypesSame(CompilerType type1, CompilerType type2,
228  bool ignore_qualifiers = false);
229 
230  /// Creates a CompilerType form the given QualType with the current
231  /// TypeSystemClang instance as the CompilerType's typesystem.
232  /// \param qt The QualType for a type that belongs to the ASTContext of this
233  /// TypeSystemClang.
234  /// \return The CompilerType representing the given QualType. If the
235  /// QualType's type pointer is a nullptr then the function returns an
236  /// invalid CompilerType.
237  CompilerType GetType(clang::QualType qt) {
238  if (qt.getTypePtrOrNull() == nullptr)
239  return CompilerType();
240  // Check that the type actually belongs to this TypeSystemClang.
241  assert(qt->getAsTagDecl() == nullptr ||
242  &qt->getAsTagDecl()->getASTContext() == &getASTContext());
243  return CompilerType(this, qt.getAsOpaquePtr());
244  }
245 
246  CompilerType GetTypeForDecl(clang::NamedDecl *decl);
247 
248  CompilerType GetTypeForDecl(clang::TagDecl *decl);
249 
250  CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
251 
252  template <typename RecordDeclType>
255  clang::DeclContext *decl_context = nullptr) {
256  CompilerType compiler_type;
257 
258  if (type_name.GetLength()) {
259  clang::ASTContext &ast = getASTContext();
260  if (!decl_context)
261  decl_context = ast.getTranslationUnitDecl();
262 
263  clang::IdentifierInfo &myIdent = ast.Idents.get(type_name.GetCString());
264  clang::DeclarationName myName =
265  ast.DeclarationNames.getIdentifier(&myIdent);
266 
267  clang::DeclContext::lookup_result result = decl_context->lookup(myName);
268 
269  if (!result.empty()) {
270  clang::NamedDecl *named_decl = *result.begin();
271  if (const RecordDeclType *record_decl =
272  llvm::dyn_cast<RecordDeclType>(named_decl))
273  compiler_type.SetCompilerType(
274  this, clang::QualType(record_decl->getTypeForDecl(), 0)
275  .getAsOpaquePtr());
276  }
277  }
278 
279  return compiler_type;
280  }
281 
283  ConstString type_name,
284  const std::initializer_list<std::pair<const char *, CompilerType>>
285  &type_fields,
286  bool packed = false);
287 
289  ConstString type_name,
290  const std::initializer_list<std::pair<const char *, CompilerType>>
291  &type_fields,
292  bool packed = false);
293 
294  static bool IsOperator(llvm::StringRef name,
295  clang::OverloadedOperatorKind &op_kind);
296 
297  // Structure, Unions, Classes
298 
299  static clang::AccessSpecifier
301 
302  static clang::AccessSpecifier
303  UnifyAccessSpecifiers(clang::AccessSpecifier lhs, clang::AccessSpecifier rhs);
304 
305  static uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl,
306  bool omit_empty_base_classes);
307 
308  /// Synthesize a clang::Module and return its ID or a default-constructed ID.
309  OptionalClangModuleID GetOrCreateClangModule(llvm::StringRef name,
310  OptionalClangModuleID parent,
311  bool is_framework = false,
312  bool is_explicit = false);
313 
314  CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
315  OptionalClangModuleID owning_module,
316  lldb::AccessType access_type,
317  llvm::StringRef name, int kind,
318  lldb::LanguageType language,
319  ClangASTMetadata *metadata = nullptr,
320  bool exports_symbols = false);
321 
323  public:
324  bool IsValid() const {
325  // Having a pack name but no packed args doesn't make sense, so mark
326  // these template parameters as invalid.
327  if (pack_name && !packed_args)
328  return false;
329  return args.size() == names.size() &&
330  (!packed_args || !packed_args->packed_args);
331  }
332 
333  bool hasParameterPack() const { return static_cast<bool>(packed_args); }
334 
335  llvm::SmallVector<const char *, 2> names;
336  llvm::SmallVector<clang::TemplateArgument, 2> args;
337 
338  const char * pack_name = nullptr;
339  std::unique_ptr<TemplateParameterInfos> packed_args;
340  };
341 
342  clang::FunctionTemplateDecl *CreateFunctionTemplateDecl(
343  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
344  clang::FunctionDecl *func_decl, const TemplateParameterInfos &infos);
345 
347  clang::FunctionDecl *func_decl, clang::FunctionTemplateDecl *Template,
348  const TemplateParameterInfos &infos);
349 
350  clang::ClassTemplateDecl *CreateClassTemplateDecl(
351  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
352  lldb::AccessType access_type, llvm::StringRef class_name, int kind,
353  const TemplateParameterInfos &infos);
354 
355  clang::TemplateTemplateParmDecl *
356  CreateTemplateTemplateParmDecl(const char *template_name);
357 
358  clang::ClassTemplateSpecializationDecl *CreateClassTemplateSpecializationDecl(
359  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
360  clang::ClassTemplateDecl *class_template_decl, int kind,
361  const TemplateParameterInfos &infos);
362 
364  CreateClassTemplateSpecializationType(clang::ClassTemplateSpecializationDecl *
365  class_template_specialization_decl);
366 
367  static clang::DeclContext *
368  GetAsDeclContext(clang::FunctionDecl *function_decl);
369 
371  bool is_method, clang::OverloadedOperatorKind op_kind,
372  uint32_t num_params);
373 
374  bool FieldIsBitfield(clang::FieldDecl *field, uint32_t &bitfield_bit_size);
375 
376  static bool RecordHasFields(const clang::RecordDecl *record_decl);
377 
378  CompilerType CreateObjCClass(llvm::StringRef name,
379  clang::DeclContext *decl_ctx,
380  OptionalClangModuleID owning_module,
381  bool isForwardDecl, bool isInternal,
382  ClangASTMetadata *metadata = nullptr);
383 
384  // Returns a mask containing bits from the TypeSystemClang::eTypeXXX
385  // enumerations
386 
387  // Namespace Declarations
388 
389  clang::NamespaceDecl *
390  GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx,
391  OptionalClangModuleID owning_module,
392  bool is_inline = false);
393 
394  // Function Types
395 
396  clang::FunctionDecl *CreateFunctionDeclaration(
397  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
398  llvm::StringRef name, const CompilerType &function_Type,
399  clang::StorageClass storage, bool is_inline);
400 
401  CompilerType CreateFunctionType(const CompilerType &result_type,
402  const CompilerType *args, unsigned num_args,
403  bool is_variadic, unsigned type_quals,
404  clang::CallingConv cc = clang::CC_C);
405 
406  clang::ParmVarDecl *
407  CreateParameterDeclaration(clang::DeclContext *decl_ctx,
408  OptionalClangModuleID owning_module,
409  const char *name, const CompilerType &param_type,
410  int storage, bool add_decl = false);
411 
412  void SetFunctionParameters(clang::FunctionDecl *function_decl,
413  llvm::ArrayRef<clang::ParmVarDecl *> params);
414 
415  CompilerType CreateBlockPointerType(const CompilerType &function_type);
416 
417  // Array Types
418 
419  CompilerType CreateArrayType(const CompilerType &element_type,
420  size_t element_count, bool is_vector);
421 
422  // Enumeration Types
423  CompilerType CreateEnumerationType(llvm::StringRef name,
424  clang::DeclContext *decl_ctx,
425  OptionalClangModuleID owning_module,
426  const Declaration &decl,
427  const CompilerType &integer_qual_type,
428  bool is_scoped);
429 
430  // Integer type functions
431 
432  CompilerType GetIntTypeFromBitSize(size_t bit_size, bool is_signed);
433 
434  CompilerType GetPointerSizedIntType(bool is_signed);
435 
436  // Floating point functions
437 
438  static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
439  size_t bit_size);
440 
441  // TypeSystem methods
442  DWARFASTParser *GetDWARFParser() override;
443  PDBASTParser *GetPDBParser() override;
444 
445  // TypeSystemClang callbacks for external source lookups.
446  void CompleteTagDecl(clang::TagDecl *);
447 
448  void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *);
449 
450  bool LayoutRecordType(
451  const clang::RecordDecl *record_decl, uint64_t &size, uint64_t &alignment,
452  llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
453  llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
454  &base_offsets,
455  llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
456  &vbase_offsets);
457 
458  /// Creates a CompilerDecl from the given Decl with the current
459  /// TypeSystemClang instance as its typesystem.
460  /// The Decl has to come from the ASTContext of this
461  /// TypeSystemClang.
462  CompilerDecl GetCompilerDecl(clang::Decl *decl) {
463  assert(&decl->getASTContext() == &getASTContext() &&
464  "CreateCompilerDecl for Decl from wrong ASTContext?");
465  return CompilerDecl(this, decl);
466  }
467 
468  // CompilerDecl override functions
469  ConstString DeclGetName(void *opaque_decl) override;
470 
471  ConstString DeclGetMangledName(void *opaque_decl) override;
472 
473  CompilerDeclContext DeclGetDeclContext(void *opaque_decl) override;
474 
475  CompilerType DeclGetFunctionReturnType(void *opaque_decl) override;
476 
477  size_t DeclGetFunctionNumArguments(void *opaque_decl) override;
478 
479  CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
480  size_t arg_idx) override;
481 
482  CompilerType GetTypeForDecl(void *opaque_decl) override;
483 
484  // CompilerDeclContext override functions
485 
486  /// Creates a CompilerDeclContext from the given DeclContext
487  /// with the current TypeSystemClang instance as its typesystem.
488  /// The DeclContext has to come from the ASTContext of this
489  /// TypeSystemClang.
490  CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx);
491 
492  /// Set the owning module for \p decl.
493  static void SetOwningModule(clang::Decl *decl,
494  OptionalClangModuleID owning_module);
495 
496  std::vector<CompilerDecl>
497  DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
498  const bool ignore_using_decls) override;
499 
500  ConstString DeclContextGetName(void *opaque_decl_ctx) override;
501 
502  ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override;
503 
504  bool DeclContextIsClassMethod(void *opaque_decl_ctx,
505  lldb::LanguageType *language_ptr,
506  bool *is_instance_method_ptr,
507  ConstString *language_object_name_ptr) override;
508 
509  bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
510  void *other_opaque_decl_ctx) override;
511 
512  // Clang specific clang::DeclContext functions
513 
514  static clang::DeclContext *
516 
517  static clang::ObjCMethodDecl *
519 
520  static clang::CXXMethodDecl *
522 
523  static clang::FunctionDecl *
525 
526  static clang::NamespaceDecl *
528 
530  const clang::Decl *object);
531 
532  static clang::ASTContext *
534 
535  // Tests
536 
537 #ifndef NDEBUG
538  bool Verify(lldb::opaque_compiler_type_t type) override;
539 #endif
540 
542  CompilerType *element_type, uint64_t *size,
543  bool *is_incomplete) override;
544 
546  CompilerType *element_type, uint64_t *size) override;
547 
548  bool IsAggregateType(lldb::opaque_compiler_type_t type) override;
549 
550  bool IsAnonymousType(lldb::opaque_compiler_type_t type) override;
551 
552  bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;
553 
554  bool IsCharType(lldb::opaque_compiler_type_t type) override;
555 
556  bool IsCompleteType(lldb::opaque_compiler_type_t type) override;
557 
558  bool IsConst(lldb::opaque_compiler_type_t type) override;
559 
561  uint32_t &length) override;
562 
563  static bool IsCXXClassType(const CompilerType &type);
564 
565  bool IsDefined(lldb::opaque_compiler_type_t type) override;
566 
568  bool &is_complex) override;
569 
570  bool IsFunctionType(lldb::opaque_compiler_type_t type) override;
571 
573  CompilerType *base_type_ptr) override;
574 
575  size_t
577 
579  const size_t index) override;
580 
582 
584  CompilerType *function_pointer_type_ptr) override;
585 
587  bool &is_signed) override;
588 
590  bool &is_signed) override;
591 
593 
594  static bool IsObjCClassType(const CompilerType &type);
595 
596  static bool IsObjCClassTypeAndHasIVars(const CompilerType &type,
597  bool check_superclass);
598 
599  static bool IsObjCObjectOrInterfaceType(const CompilerType &type);
600 
601  static bool IsObjCObjectPointerType(const CompilerType &type,
602  CompilerType *target_type = nullptr);
603 
605 
606  static bool IsClassType(lldb::opaque_compiler_type_t type);
607 
608  static bool IsEnumType(lldb::opaque_compiler_type_t type);
609 
611  CompilerType *target_type, // Can pass nullptr
612  bool check_cplusplus, bool check_objc) override;
613 
615 
617  CompilerType *pointee_type) override;
618 
620  CompilerType *pointee_type) override;
621 
623  CompilerType *pointee_type, bool *is_rvalue) override;
624 
625  bool IsScalarType(lldb::opaque_compiler_type_t type) override;
626 
627  bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
628 
629  bool IsVoidType(lldb::opaque_compiler_type_t type) override;
630 
631  bool CanPassInRegisters(const CompilerType &type) override;
632 
633  bool SupportsLanguage(lldb::LanguageType language) override;
634 
635  static llvm::Optional<std::string> GetCXXClassName(const CompilerType &type);
636 
637  // Type Completion
638 
639  bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
640 
641  // Accessors
642 
644 
646 
648  CompilerType *pointee_or_element_compiler_type) override;
649 
652 
653  lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
654 
655  unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
656 
657  // Creating related types
658 
660  ExecutionContextScope *exe_scope) override;
661 
663  uint64_t size) override;
664 
666 
669 
672 
673  // Returns -1 if this isn't a function of if the function doesn't have a
674  // prototype Returns a value >= 0 if there is a prototype.
676 
678  size_t idx) override;
679 
682 
684 
687  size_t idx) override;
688 
690 
692 
694 
697 
700 
702 
704 
706 
708 
709  /// Using the current type, create a new typedef to that type using
710  /// "typedef_name" as the name and "decl_ctx" as the decl context.
711  /// \param opaque_payload is an opaque TypePayloadClang.
713  const char *name,
714  const CompilerDeclContext &decl_ctx,
715  uint32_t opaque_payload) override;
716 
717  // If the current object represents a typedef type, get the underlying type
719 
720  // Create related types using the current type's AST
721  CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
722 
723  // Exploring the type
724 
725  const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) override;
726 
727  llvm::Optional<uint64_t> GetByteSize(lldb::opaque_compiler_type_t type,
728  ExecutionContextScope *exe_scope) {
729  if (llvm::Optional<uint64_t> bit_size = GetBitSize(type, exe_scope))
730  return (*bit_size + 7) / 8;
731  return llvm::None;
732  }
733 
734  llvm::Optional<uint64_t>
736  ExecutionContextScope *exe_scope) override;
737 
739  uint64_t &count) override;
740 
742 
743  llvm::Optional<size_t>
745  ExecutionContextScope *exe_scope) override;
746 
748  bool omit_empty_base_classes,
749  const ExecutionContext *exe_ctx) override;
750 
752 
755 
756  static lldb::BasicType
758  ConstString name);
759 
760  void ForEachEnumerator(
762  std::function<bool(const CompilerType &integer_type,
763  ConstString name,
764  const llvm::APSInt &value)> const &callback) override;
765 
767 
769  std::string &name, uint64_t *bit_offset_ptr,
770  uint32_t *bitfield_bit_size_ptr,
771  bool *is_bitfield_ptr) override;
772 
774 
776 
778  size_t idx,
779  uint32_t *bit_offset_ptr) override;
780 
782  size_t idx,
783  uint32_t *bit_offset_ptr) override;
784 
785  static uint32_t GetNumPointeeChildren(clang::QualType type);
786 
788  lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
789  bool transparent_pointers, bool omit_empty_base_classes,
790  bool ignore_array_bounds, std::string &child_name,
791  uint32_t &child_byte_size, int32_t &child_byte_offset,
792  uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
793  bool &child_is_base_class, bool &child_is_deref_of_parent,
794  ValueObject *valobj, uint64_t &language_flags) override;
795 
796  // Lookup a child given a name. This function will match base class names and
797  // member member names in "clang_type" only, not descendants.
799  const char *name,
800  bool omit_empty_base_classes) override;
801 
802  // Lookup a child member given a name. This function will match member names
803  // only and will descend into "clang_type" children in search for the first
804  // member in this class, or any base class that matches "name".
805  // TODO: Return all matches for a given name by returning a
806  // vector<vector<uint32_t>>
807  // so we catch all names that match a given child name, not just the first.
808  size_t
810  const char *name, bool omit_empty_base_classes,
811  std::vector<uint32_t> &child_indexes) override;
812 
814 
817  size_t idx) override;
819  size_t idx) override;
820  llvm::Optional<CompilerType::IntegralTemplateArgument>
822  size_t idx) override;
823 
824  CompilerType GetTypeForFormatters(void *type) override;
825 
826 #define LLDB_INVALID_DECL_LEVEL UINT32_MAX
827  // LLDB_INVALID_DECL_LEVEL is returned by CountDeclLevels if child_decl_ctx
828  // could not be found in decl_ctx.
829  uint32_t CountDeclLevels(clang::DeclContext *frame_decl_ctx,
830  clang::DeclContext *child_decl_ctx,
831  ConstString *child_name = nullptr,
832  CompilerType *child_type = nullptr);
833 
834  // Modifying RecordType
835  static clang::FieldDecl *AddFieldToRecordType(const CompilerType &type,
836  llvm::StringRef name,
837  const CompilerType &field_type,
838  lldb::AccessType access,
839  uint32_t bitfield_bit_size);
840 
841  static void BuildIndirectFields(const CompilerType &type);
842 
843  static void SetIsPacked(const CompilerType &type);
844 
845  static clang::VarDecl *AddVariableToRecordType(const CompilerType &type,
846  llvm::StringRef name,
847  const CompilerType &var_type,
848  lldb::AccessType access);
849 
850  /// Initializes a variable with an integer value.
851  /// \param var The variable to initialize. Must not already have an
852  /// initializer and must have an integer or enum type.
853  /// \param init_value The integer value that the variable should be
854  /// initialized to. Has to match the bit width of the
855  /// variable type.
856  static void SetIntegerInitializerForVariable(clang::VarDecl *var,
857  const llvm::APInt &init_value);
858 
859  /// Initializes a variable with a floating point value.
860  /// \param var The variable to initialize. Must not already have an
861  /// initializer and must have a floating point type.
862  /// \param init_value The float value that the variable should be
863  /// initialized to.
864  static void
865  SetFloatingInitializerForVariable(clang::VarDecl *var,
866  const llvm::APFloat &init_value);
867 
868  clang::CXXMethodDecl *AddMethodToCXXRecordType(
869  lldb::opaque_compiler_type_t type, llvm::StringRef name,
870  const char *mangled_name, const CompilerType &method_type,
871  lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
872  bool is_explicit, bool is_attr_used, bool is_artificial);
873 
875 
876  // C++ Base Classes
877  std::unique_ptr<clang::CXXBaseSpecifier>
879  lldb::AccessType access, bool is_virtual,
880  bool base_of_class);
881 
882  bool TransferBaseClasses(
884  std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases);
885 
886  static bool SetObjCSuperClass(const CompilerType &type,
887  const CompilerType &superclass_compiler_type);
888 
889  static bool AddObjCClassProperty(const CompilerType &type,
890  const char *property_name,
891  const CompilerType &property_compiler_type,
892  clang::ObjCIvarDecl *ivar_decl,
893  const char *property_setter_name,
894  const char *property_getter_name,
895  uint32_t property_attributes,
896  ClangASTMetadata *metadata);
897 
898  static clang::ObjCMethodDecl *AddMethodToObjCObjectType(
899  const CompilerType &type,
900  const char *name, // the full symbol name as seen in the symbol table
901  // (lldb::opaque_compiler_type_t type, "-[NString
902  // stringWithCString:]")
903  const CompilerType &method_compiler_type, lldb::AccessType access,
904  bool is_artificial, bool is_variadic, bool is_objc_direct_call);
905 
907  bool has_extern);
908 
909  // Tag Declarations
910  static bool StartTagDeclarationDefinition(const CompilerType &type);
911 
912  static bool CompleteTagDeclarationDefinition(const CompilerType &type);
913 
914  // Modifying Enumeration types
915  clang::EnumConstantDecl *AddEnumerationValueToEnumerationType(
916  const CompilerType &enum_type, const Declaration &decl, const char *name,
917  int64_t enum_value, uint32_t enum_value_bit_size);
918  clang::EnumConstantDecl *AddEnumerationValueToEnumerationType(
919  const CompilerType &enum_type, const Declaration &decl, const char *name,
920  const llvm::APSInt &value);
921 
922  /// Returns the underlying integer type for an enum type. If the given type
923  /// is invalid or not an enum-type, the function returns an invalid
924  /// CompilerType.
925  CompilerType GetEnumerationIntegerType(CompilerType type);
926 
927  // Pointers & References
928 
929  // Call this function using the class type when you want to make a member
930  // pointer type to pointee_type.
931  static CompilerType CreateMemberPointerType(const CompilerType &type,
932  const CompilerType &pointee_type);
933 
934  // Dumping types
935 #ifndef NDEBUG
936  /// Convenience LLVM-style dump method for use in the debugger only.
937  /// In contrast to the other \p Dump() methods this directly invokes
938  /// \p clang::QualType::dump().
939  LLVM_DUMP_METHOD void dump(lldb::opaque_compiler_type_t type) const override;
940 #endif
941 
942  /// \see lldb_private::TypeSystem::Dump
943  void Dump(llvm::raw_ostream &output) override;
944 
945  /// Dump clang AST types from the symbol file.
946  ///
947  /// \param[in] s
948  /// A stream to send the dumped AST node(s) to
949  /// \param[in] symbol_name
950  /// The name of the symbol to dump, if it is empty dump all the symbols
951  void DumpFromSymbolFile(Stream &s, llvm::StringRef symbol_name);
952 
953  void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
954  Stream *s, lldb::Format format, const DataExtractor &data,
955  lldb::offset_t data_offset, size_t data_byte_size,
956  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
957  bool show_types, bool show_summary, bool verbose,
958  uint32_t depth) override;
959 
960  bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
961  lldb::Format format, const DataExtractor &data,
962  lldb::offset_t data_offset, size_t data_byte_size,
963  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
964  ExecutionContextScope *exe_scope) override;
965 
966  void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
967  Stream *s, const DataExtractor &data,
968  lldb::offset_t data_offset, size_t data_byte_size) override;
969 
970  void DumpTypeDescription(
973 
974  void DumpTypeDescription(
975  lldb::opaque_compiler_type_t type, Stream *s,
977 
978  static void DumpTypeName(const CompilerType &type);
979 
980  static clang::EnumDecl *GetAsEnumDecl(const CompilerType &type);
981 
982  static clang::RecordDecl *GetAsRecordDecl(const CompilerType &type);
983 
984  static clang::TagDecl *GetAsTagDecl(const CompilerType &type);
985 
986  static clang::TypedefNameDecl *GetAsTypedefDecl(const CompilerType &type);
987 
988  static clang::CXXRecordDecl *
990 
991  static clang::ObjCInterfaceDecl *
992  GetAsObjCInterfaceDecl(const CompilerType &type);
993 
994  clang::ClassTemplateDecl *ParseClassTemplateDecl(
995  clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
996  lldb::AccessType access_type, const char *parent_name, int tag_decl_kind,
997  const TypeSystemClang::TemplateParameterInfos &template_param_infos);
998 
999  clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx,
1000  OptionalClangModuleID owning_module);
1001 
1002  clang::UsingDirectiveDecl *
1003  CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
1004  OptionalClangModuleID owning_module,
1005  clang::NamespaceDecl *ns_decl);
1006 
1007  clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
1008  OptionalClangModuleID owning_module,
1009  clang::NamedDecl *target);
1010 
1011  clang::VarDecl *CreateVariableDeclaration(clang::DeclContext *decl_context,
1012  OptionalClangModuleID owning_module,
1013  const char *name,
1014  clang::QualType type);
1015 
1017  GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType basic_type);
1018 
1019  static clang::QualType GetQualType(lldb::opaque_compiler_type_t type) {
1020  if (type)
1021  return clang::QualType::getFromOpaquePtr(type);
1022  return clang::QualType();
1023  }
1024 
1025  static clang::QualType
1027  if (type)
1028  return clang::QualType::getFromOpaquePtr(type).getCanonicalType();
1029  return clang::QualType();
1030  }
1031 
1032  clang::DeclarationName
1033  GetDeclarationName(llvm::StringRef name,
1034  const CompilerType &function_clang_type);
1035 
1036  clang::LangOptions *GetLangOpts() const {
1037  return m_language_options_up.get();
1038  }
1039  clang::SourceManager *GetSourceMgr() const {
1040  return m_source_manager_up.get();
1041  }
1042 
1043 private:
1044  /// Returns the PrintingPolicy used when generating the internal type names.
1045  /// These type names are mostly used for the formatter selection.
1046  clang::PrintingPolicy GetTypePrintingPolicy();
1047  /// Returns the internal type name for the given NamedDecl using the
1048  /// type printing policy.
1049  std::string GetTypeNameForDecl(const clang::NamedDecl *named_decl);
1050 
1051  const clang::ClassTemplateSpecializationDecl *
1053 
1054  // Classes that inherit from TypeSystemClang can see and modify these
1056  std::unique_ptr<clang::ASTContext> m_ast_up;
1057  std::unique_ptr<clang::LangOptions> m_language_options_up;
1058  std::unique_ptr<clang::FileManager> m_file_manager_up;
1059  std::unique_ptr<clang::SourceManager> m_source_manager_up;
1060  std::unique_ptr<clang::DiagnosticsEngine> m_diagnostics_engine_up;
1061  std::unique_ptr<clang::DiagnosticConsumer> m_diagnostic_consumer_up;
1062  std::shared_ptr<clang::TargetOptions> m_target_options_rp;
1063  std::unique_ptr<clang::TargetInfo> m_target_info_up;
1064  std::unique_ptr<clang::IdentifierTable> m_identifier_table_up;
1065  std::unique_ptr<clang::SelectorTable> m_selector_table_up;
1066  std::unique_ptr<clang::Builtin::Context> m_builtins_up;
1067  std::unique_ptr<clang::HeaderSearch> m_header_search_up;
1068  std::unique_ptr<clang::ModuleMap> m_module_map_up;
1069  std::unique_ptr<DWARFASTParserClang> m_dwarf_ast_parser_up;
1070  std::unique_ptr<PDBASTParser> m_pdb_ast_parser_up;
1071  std::unique_ptr<clang::MangleContext> m_mangle_ctx_up;
1073  bool m_ast_owned = false;
1074  /// A string describing what this TypeSystemClang represents (e.g.,
1075  /// AST for debug information, an expression, some other utility ClangAST).
1076  /// Useful for logging and debugging.
1078 
1079  typedef llvm::DenseMap<const clang::Decl *, ClangASTMetadata> DeclMetadataMap;
1080  /// Maps Decls to their associated ClangASTMetadata.
1082 
1083  typedef llvm::DenseMap<const clang::Type *, ClangASTMetadata> TypeMetadataMap;
1084  /// Maps Types to their associated ClangASTMetadata.
1086 
1087  typedef llvm::DenseMap<const clang::CXXRecordDecl *, clang::AccessSpecifier>
1089  /// Maps CXXRecordDecl to their most recent added method/field's
1090  /// AccessSpecifier.
1092 
1093  /// The sema associated that is currently used to build this ASTContext.
1094  /// May be null if we are already done parsing this ASTContext or the
1095  /// ASTContext wasn't created by parsing source code.
1096  clang::Sema *m_sema = nullptr;
1097 
1098  // For TypeSystemClang only
1100  const TypeSystemClang &operator=(const TypeSystemClang &);
1101  /// Creates the internal ASTContext.
1102  void CreateASTContext();
1103  void SetTargetTriple(llvm::StringRef target_triple);
1104 };
1105 
1106 /// The TypeSystemClang instance used for the scratch ASTContext in a
1107 /// lldb::Target.
1109  /// LLVM RTTI support
1110  static char ID;
1111 
1112 public:
1113  ScratchTypeSystemClang(Target &target, llvm::Triple triple);
1114 
1115  ~ScratchTypeSystemClang() override = default;
1116 
1117  void Finalize() override;
1118 
1119  /// The different kinds of isolated ASTs within the scratch TypeSystem.
1120  ///
1121  /// These ASTs are isolated from the main scratch AST and are each
1122  /// dedicated to a special language option/feature that makes the contained
1123  /// AST nodes incompatible with other AST nodes.
1125  /// The isolated AST for declarations/types from expressions that imported
1126  /// type information from a C++ module. The templates from a C++ module
1127  /// often conflict with the templates we generate from debug information,
1128  /// so we put these types in their own AST.
1130  };
1131 
1132  /// Alias for requesting the default scratch TypeSystemClang in GetForTarget.
1133  // This isn't constexpr as gtest/llvm::Optional comparison logic is trying
1134  // to get the address of this for pretty-printing.
1135  static const llvm::NoneType DefaultAST;
1136 
1137  /// Infers the appropriate sub-AST from Clang's LangOptions.
1138  static llvm::Optional<IsolatedASTKind>
1139  InferIsolatedASTKindFromLangOpts(const clang::LangOptions &l) {
1140  // If modules are activated we want the dedicated C++ module AST.
1141  // See IsolatedASTKind::CppModules for more info.
1142  if (l.Modules)
1143  return IsolatedASTKind::CppModules;
1144  return DefaultAST;
1145  }
1146 
1147  /// Returns the scratch TypeSystemClang for the given target.
1148  /// \param target The Target which scratch TypeSystemClang should be returned.
1149  /// \param ast_kind Allows requesting a specific sub-AST instead of the
1150  /// default scratch AST. See also `IsolatedASTKind`.
1151  /// \param create_on_demand If the scratch TypeSystemClang instance can be
1152  /// created by this call if it doesn't exist yet. If it doesn't exist yet and
1153  /// this parameter is false, this function returns a nullptr.
1154  /// \return The scratch type system of the target or a nullptr in case an
1155  /// error occurred.
1156  static TypeSystemClang *
1157  GetForTarget(Target &target,
1158  llvm::Optional<IsolatedASTKind> ast_kind = DefaultAST,
1159  bool create_on_demand = true);
1160 
1161  /// Returns the scratch TypeSystemClang for the given target. The returned
1162  /// TypeSystemClang will be the scratch AST or a sub-AST, depending on which
1163  /// fits best to the passed LangOptions.
1164  /// \param target The Target which scratch TypeSystemClang should be returned.
1165  /// \param lang_opts The LangOptions of a clang ASTContext that the caller
1166  /// wants to export type information from. This is used to
1167  /// find the best matching sub-AST that will be returned.
1169  const clang::LangOptions &lang_opts) {
1170  return GetForTarget(target, InferIsolatedASTKindFromLangOpts(lang_opts));
1171  }
1172 
1173  /// \see lldb_private::TypeSystem::Dump
1174  void Dump(llvm::raw_ostream &output) override;
1175 
1176  UserExpression *
1177  GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
1178  lldb::LanguageType language,
1179  Expression::ResultType desired_type,
1180  const EvaluateExpressionOptions &options,
1181  ValueObject *ctx_obj) override;
1182 
1183  FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
1184  const Address &function_address,
1185  const ValueList &arg_value_list,
1186  const char *name) override;
1187 
1188  std::unique_ptr<UtilityFunction>
1189  CreateUtilityFunction(std::string text, std::string name) override;
1190 
1192 
1193  /// Unregisters the given ASTContext as a source from the scratch AST (and
1194  /// all sub-ASTs).
1195  /// \see ClangASTImporter::ForgetSource
1196  void ForgetSource(clang::ASTContext *src_ctx, ClangASTImporter &importer);
1197 
1198  // llvm casting support
1199  bool isA(const void *ClassID) const override {
1200  return ClassID == &ID || TypeSystemClang::isA(ClassID);
1201  }
1202  static bool classof(const TypeSystem *ts) { return ts->isA(&ID); }
1203 
1204 private:
1205  std::unique_ptr<ClangASTSource> CreateASTSource();
1206  /// Returns the requested sub-AST.
1207  /// Will lazily create the sub-AST if it hasn't been created before.
1209 
1210  /// The target triple.
1211  /// This was potentially adjusted and might not be identical to the triple
1212  /// of `m_target_wp`.
1213  llvm::Triple m_triple;
1214  lldb::TargetWP m_target_wp;
1215  /// The persistent variables associated with this process for the expression
1216  /// parser.
1217  std::unique_ptr<ClangPersistentVariables> m_persistent_variables;
1218  /// The ExternalASTSource that performs lookups and completes minimally
1219  /// imported types.
1220  std::unique_ptr<ClangASTSource> m_scratch_ast_source_up;
1221 
1222  // FIXME: GCC 5.x doesn't support enum as map keys.
1223  typedef int IsolatedASTKey;
1224 
1225  /// Map from IsolatedASTKind to their actual TypeSystemClang instance.
1226  /// This map is lazily filled with sub-ASTs and should be accessed via
1227  /// `GetSubAST` (which lazily fills this map).
1228  std::unordered_map<IsolatedASTKey, std::unique_ptr<TypeSystemClang>>
1230 };
1231 
1232 } // namespace lldb_private
1233 
1234 #endif // LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_TYPESYSTEMCLANG_H
lldb_private::TypeSystemClang::GetIndexOfChildMemberWithName
size_t GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes, std::vector< uint32_t > &child_indexes) override
Definition: TypeSystemClang.cpp:6664
lldb_private::TypeSystemClang::GetNumberOfFunctionArguments
size_t GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3119
lldb_private::TypePayloadClang::ObjCClassBit
static constexpr unsigned ObjCClassBit
Definition: TypeSystemClang.h:82
lldb_private::TypeSystemClang::CreateBlockPointerType
CompilerType CreateBlockPointerType(const CompilerType &function_type)
Definition: TypeSystemClang.cpp:2235
lldb_private::TypeSystemClang::IsPossibleDynamicType
bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type, CompilerType *target_type, bool check_cplusplus, bool check_objc) override
Definition: TypeSystemClang.cpp:3535
lldb_private::TypeSystemClang::IsReferenceType
bool IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue) override
Definition: TypeSystemClang.cpp:3374
lldb_private::TypeSystemClang::CreateParameterDeclaration
clang::ParmVarDecl * CreateParameterDeclaration(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, const char *name, const CompilerType &param_type, int storage, bool add_decl=false)
Definition: TypeSystemClang.cpp:2210
lldb_private::TypePayloadClang::TypePayloadClang
TypePayloadClang()=default
lldb_private::TypeSystemClang::DeclGetName
ConstString DeclGetName(void *opaque_decl) override
Definition: TypeSystemClang.cpp:9344
lldb_private::TypeSystemClang::CreateBlockDeclaration
clang::BlockDecl * CreateBlockDeclaration(clang::DeclContext *ctx, OptionalClangModuleID owning_module)
Definition: TypeSystemClang.cpp:1921
lldb_private::TypeSystemClang::CreateObjCClass
CompilerType CreateObjCClass(llvm::StringRef name, clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, bool isForwardDecl, bool isInternal, ClangASTMetadata *metadata=nullptr)
Definition: TypeSystemClang.cpp:1808
lldb_private::TypeSystemClang::m_target_triple
std::string m_target_triple
Definition: TypeSystemClang.h:1055
lldb_private::TypeSystemClang::IsScalarType
bool IsScalarType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3664
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::OptionalClangModuleID::OptionalClangModuleID
OptionalClangModuleID(unsigned id)
Definition: TypeSystemClang.h:61
lldb_private::TypeSystemClang::GetPDBParser
PDBASTParser * GetPDBParser() override
Definition: TypeSystemClang.cpp:9316
lldb_private::TypeSystemClang::m_pdb_ast_parser_up
std::unique_ptr< PDBASTParser > m_pdb_ast_parser_up
Definition: TypeSystemClang.h:1070
ExpressionVariable.h
lldb_private::OptionalClangModuleID::HasValue
bool HasValue() const
Definition: TypeSystemClang.h:62
lldb_private::TypeSystemClang::DumpTypeValue
bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) override
Definition: TypeSystemClang.cpp:8927
lldb_private::TypeSystemClang::GetNumPointeeChildren
static uint32_t GetNumPointeeChildren(clang::QualType type)
Definition: TypeSystemClang.cpp:6012
lldb_private::TypeSystemClang::GetAsTagDecl
static clang::TagDecl * GetAsTagDecl(const CompilerType &type)
Definition: TypeSystemClang.cpp:7246
lldb_private::TypeSystemClang::GetAtomicType
CompilerType GetAtomicType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4569
lldb_private::TypeSystemClang::m_diagnostic_consumer_up
std::unique_ptr< clang::DiagnosticConsumer > m_diagnostic_consumer_up
Definition: TypeSystemClang.h:1061
lldb_private::TypeSystemClang::IsCompleteType
bool IsCompleteType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:2971
lldb_private::TypeSystemClang::m_ast_owned
bool m_ast_owned
Definition: TypeSystemClang.h:1073
lldb_private::TypeSystemClang::TransferBaseClasses
bool TransferBaseClasses(lldb::opaque_compiler_type_t type, std::vector< std::unique_ptr< clang::CXXBaseSpecifier >> bases)
Definition: TypeSystemClang.cpp:7779
lldb_private::TypeSystemClang::GetCompilerDecl
CompilerDecl GetCompilerDecl(clang::Decl *decl)
Creates a CompilerDecl from the given Decl with the current TypeSystemClang instance as its typesyste...
Definition: TypeSystemClang.h:462
lldb_private::TypeSystemClang::m_pointer_byte_size
uint32_t m_pointer_byte_size
Definition: TypeSystemClang.h:1072
lldb_private::TypeSystemClang::getASTContext
clang::ASTContext & getASTContext()
Returns the clang::ASTContext instance managed by this TypeSystemClang.
Definition: TypeSystemClang.cpp:686
lldb_private::TypeSystemClang::SetFloatingInitializerForVariable
static void SetFloatingInitializerForVariable(clang::VarDecl *var, const llvm::APFloat &init_value)
Initializes a variable with a floating point value.
Definition: TypeSystemClang.cpp:7549
lldb_private::TypeSystemClang::CreateInstance
static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, Module *module, Target *target)
Definition: TypeSystemClang.cpp:575
lldb_private::TypeSystemClang::CreateDeclContext
CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx)
Creates a CompilerDeclContext from the given DeclContext with the current TypeSystemClang instance as...
Definition: TypeSystemClang.cpp:1200
lldb::Format
Format
Display format definitions.
Definition: lldb-enumerations.h:155
lldb_private::TypeSystemClang::IsAnonymousType
bool IsAnonymousType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:2823
lldb_private::ScratchTypeSystemClang::GetPersistentExpressionState
PersistentExpressionState * GetPersistentExpressionState() override
Definition: TypeSystemClang.cpp:9888
lldb_private::TypeSystemClang::GetDirectBaseClassAtIndex
CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override
Definition: TypeSystemClang.cpp:5869
lldb_private::TypeSystemClang::GetNonReferenceType
CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4521
lldb_private::TypeSystemClang::GetSupportedLanguagesForExpressions
static LanguageSet GetSupportedLanguagesForExpressions()
Definition: TypeSystemClang.cpp:629
lldb_private::TypeSystemClang::CreateTemplateTemplateParmDecl
clang::TemplateTemplateParmDecl * CreateTemplateTemplateParmDecl(const char *template_name)
Definition: TypeSystemClang.cpp:1640
lldb_private::TypeSystemClang::CreateFunctionType
CompilerType CreateFunctionType(const CompilerType &result_type, const CompilerType *args, unsigned num_args, bool is_variadic, unsigned type_quals, clang::CallingConv cc=clang::CC_C)
Definition: TypeSystemClang.cpp:2172
lldb_private::TypeSystemClang::GetIntTypeFromBitSize
CompilerType GetIntTypeFromBitSize(size_t bit_size, bool is_signed)
Definition: TypeSystemClang.cpp:2338
lldb_private::TypeSystemClang::m_language_options_up
std::unique_ptr< clang::LangOptions > m_language_options_up
Definition: TypeSystemClang.h:1057
lldb_private::TypeSystemClang::GetPointerByteSize
uint32_t GetPointerByteSize() override
Definition: TypeSystemClang.cpp:921
lldb_private::TypeSystemClang::DeclContextGetScopeQualifiedName
ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override
Definition: TypeSystemClang.cpp:9622
lldb_private::TypeSystemClang::GetMetadata
ClangASTMetadata * GetMetadata(const clang::Decl *object)
Definition: TypeSystemClang.cpp:2566
lldb_private::TypeSystemClang::m_builtins_up
std::unique_ptr< clang::Builtin::Context > m_builtins_up
Definition: TypeSystemClang.h:1066
lldb_private::TypeSystemClang::AddRestrictModifier
CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4596
lldb_private::TypeSystemClang::CreateFunctionDeclaration
clang::FunctionDecl * CreateFunctionDeclaration(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, llvm::StringRef name, const CompilerType &function_Type, clang::StorageClass storage, bool is_inline)
Definition: TypeSystemClang.cpp:2139
lldb_private::TypeSystemClang::GetTranslationUnitDecl
clang::TranslationUnitDecl * GetTranslationUnitDecl()
Definition: TypeSystemClang.h:223
lldb_private::TypeSystemClang::GetFullyUnqualifiedType
CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4292
lldb_private::TypeSystemClang::DeclContextGetMetaData
static ClangASTMetadata * DeclContextGetMetaData(const CompilerDeclContext &dc, const clang::Decl *object)
Definition: TypeSystemClang.cpp:9733
lldb_private::TypeSystemClang::GetIntegralTemplateArgument
llvm::Optional< CompilerType::IntegralTemplateArgument > GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx) override
Definition: TypeSystemClang.cpp:7208
lldb_private::TypeSystemClang::GetArrayType
CompilerType GetArrayType(lldb::opaque_compiler_type_t type, uint64_t size) override
Definition: TypeSystemClang.cpp:4248
lldb_private::ScratchTypeSystemClang::IsolatedASTKey
int IsolatedASTKey
Definition: TypeSystemClang.h:1223
lldb_private::TypeSystemClang::GetASTContext
static TypeSystemClang * GetASTContext(clang::ASTContext *ast_ctx)
Definition: TypeSystemClang.cpp:758
lldb_private::OptionalClangModuleID::GetValue
unsigned GetValue() const
Definition: TypeSystemClang.h:63
lldb_private::TypeSystemClang::m_target_info_up
std::unique_ptr< clang::TargetInfo > m_target_info_up
Definition: TypeSystemClang.h:1063
lldb_private::TypeSystemClang::GetTemplateArgumentKind
lldb::TemplateArgumentKind GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx) override
Definition: TypeSystemClang.cpp:7153
lldb_private::TypeSystemClang::GetNumBaseClasses
static uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
Definition: TypeSystemClang.cpp:1835
lldb_private::Flags::Clear
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
lldb_private::TypeSystemClang::GetBuiltinTypeForEncodingAndBitSize
CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size) override
Definition: TypeSystemClang.cpp:795
lldb_private::ScratchTypeSystemClang::CppModules
@ CppModules
The isolated AST for declarations/types from expressions that imported type information from a C++ mo...
Definition: TypeSystemClang.h:1129
lldb_private::ScratchTypeSystemClang::ScratchTypeSystemClang
ScratchTypeSystemClang(Target &target, llvm::Triple triple)
Definition: TypeSystemClang.cpp:9778
lldb_private::TypeSystemClang::IsArrayType
bool IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) override
Definition: TypeSystemClang.cpp:2845
lldb_private::TypeSystemClang::IsConst
bool IsConst(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:2982
lldb_private::TypeSystemClang::GetCanonicalQualType
static clang::QualType GetCanonicalQualType(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.h:1026
lldb_private::ScratchTypeSystemClang::m_triple
llvm::Triple m_triple
The target triple.
Definition: TypeSystemClang.h:1213
lldb_private::EvaluateExpressionOptions
Definition: Target.h:281
lldb_private::ScratchTypeSystemClang::m_scratch_ast_source_up
std::unique_ptr< ClangASTSource > m_scratch_ast_source_up
The ExternalASTSource that performs lookups and completes minimally imported types.
Definition: TypeSystemClang.h:1220
lldb_private::TypeSystemClang::CreateEnumerationType
CompilerType CreateEnumerationType(llvm::StringRef name, clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, const Declaration &decl, const CompilerType &integer_qual_type, bool is_scoped)
Definition: TypeSystemClang.cpp:2309
lldb_private::ScratchTypeSystemClang::DefaultAST
static const llvm::NoneType DefaultAST
Alias for requesting the default scratch TypeSystemClang in GetForTarget.
Definition: TypeSystemClang.h:1135
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::Flags
Definition: Flags.h:22
lldb_private::TypeSystemClang::DeclContextIsContainedInLookup
bool DeclContextIsContainedInLookup(void *opaque_decl_ctx, void *other_opaque_decl_ctx) override
Definition: TypeSystemClang.cpp:9672
lldb_private::TypeSystemClang::getSema
clang::Sema * getSema()
Definition: TypeSystemClang.h:170
lldb_private::TypeSystemClang::m_target_options_rp
std::shared_ptr< clang::TargetOptions > m_target_options_rp
Definition: TypeSystemClang.h:1062
lldb_private::CompilerDecl
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
lldb_private::Module
Definition: Module.h:85
lldb_private::TypeSystemClang::m_dwarf_ast_parser_up
std::unique_ptr< DWARFASTParserClang > m_dwarf_ast_parser_up
Definition: TypeSystemClang.h:1069
lldb_private::TypeSystemClang::GetTypeForIdentifier
CompilerType GetTypeForIdentifier(ConstString type_name, clang::DeclContext *decl_context=nullptr)
Definition: TypeSystemClang.h:254
lldb_private::ScratchTypeSystemClang::isA
bool isA(const void *ClassID) const override
Definition: TypeSystemClang.h:1199
lldb_private::TypeSystemClang::LayoutRecordType
bool LayoutRecordType(const clang::RecordDecl *record_decl, uint64_t &size, uint64_t &alignment, llvm::DenseMap< const clang::FieldDecl *, uint64_t > &field_offsets, llvm::DenseMap< const clang::CXXRecordDecl *, clang::CharUnits > &base_offsets, llvm::DenseMap< const clang::CXXRecordDecl *, clang::CharUnits > &vbase_offsets)
Definition: TypeSystemClang.cpp:9322
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::Flags::Test
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:96
lldb_private::TypeSystemClang::GetBuiltinTypeByName
CompilerType GetBuiltinTypeByName(ConstString name) override
Definition: TypeSystemClang.cpp:5472
lldb_private::ValueList
Definition: Value.h:157
lldb_private::TypeSystemClang::IsPointerOrReferenceType
bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override
Definition: TypeSystemClang.cpp:3309
lldb_private::TypeSystemClang::IsObjCObjectPointerType
static bool IsObjCObjectPointerType(const CompilerType &type, CompilerType *target_type=nullptr)
Definition: TypeSystemClang.cpp:3730
lldb_private::TypeSystemClang::m_selector_table_up
std::unique_ptr< clang::SelectorTable > m_selector_table_up
Definition: TypeSystemClang.h:1065
lldb_private::TypeSystemClang::m_ast_up
std::unique_ptr< clang::ASTContext > m_ast_up
Definition: TypeSystemClang.h:1056
lldb_private::TypePayloadClang::GetOwningModule
OptionalClangModuleID GetOwningModule()
Definition: TypeSystemClang.h:88
lldb_private::UserExpression
Definition: UserExpression.h:35
lldb_private::TypePayloadClang::SetIsCompleteObjCClass
void SetIsCompleteObjCClass(bool is_complete_objc_class)
Definition: TypeSystemClang.h:84
lldb_private::TypeSystemClang::GetNumChildren
uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes, const ExecutionContext *exe_ctx) override
Definition: TypeSystemClang.cpp:5318
lldb_private::TypeSystemClang::IsFunctionPointerType
bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3146
lldb_private::TypeSystemClang::AddVariableToRecordType
static clang::VarDecl * AddVariableToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &var_type, lldb::AccessType access)
Definition: TypeSystemClang.cpp:7494
lldb_private::TypePayloadClang
The implementation of lldb::Type's m_payload field for TypeSystemClang.
Definition: TypeSystemClang.h:67
lldb::BasicType
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
Definition: lldb-enumerations.h:747
lldb_private::TypeSystemClang::m_file_manager_up
std::unique_ptr< clang::FileManager > m_file_manager_up
Definition: TypeSystemClang.h:1058
lldb_private::TypeSystemClang::GetTypeNameForDecl
std::string GetTypeNameForDecl(const clang::NamedDecl *named_decl)
Returns the internal type name for the given NamedDecl using the type printing policy.
Definition: TypeSystemClang.cpp:2131
lldb_private::TypeSystem::isA
virtual bool isA(const void *ClassID) const =0
lldb_private::TypeSystemClang::DeclContextGetAsCXXMethodDecl
static clang::CXXMethodDecl * DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc)
Definition: TypeSystemClang.cpp:9709
lldb_private::Target
Definition: Target.h:473
lldb_private::TypeSystemClang::DeclContextFindDeclByName
std::vector< CompilerDecl > DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name, const bool ignore_using_decls) override
Definition: TypeSystemClang.cpp:9432
lldb_private::TypeSystemClang::DeclsAreEquivalent
static bool DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl)
Definition: TypeSystemClang.cpp:2423
lldb_private::TypeSystemClang::GetAsEnumDecl
static clang::EnumDecl * GetAsEnumDecl(const CompilerType &type)
Definition: TypeSystemClang.cpp:7230
lldb_private::TypeSystemClang::GetFloatTypeSemantics
const llvm::fltSemantics & GetFloatTypeSemantics(size_t byte_size) override
Definition: TypeSystemClang.cpp:4666
lldb_private::TypeSystemClang::CreateArrayType
CompilerType CreateArrayType(const CompilerType &element_type, size_t element_count, bool is_vector)
Definition: TypeSystemClang.cpp:2244
lldb_private::TypeSystemClang::GetPluginNameStatic
static llvm::StringRef GetPluginNameStatic()
Definition: TypeSystemClang.h:142
lldb_private::TypeSystemClang::GetNumDirectBaseClasses
uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:5797
lldb_private::TypeSystemClang::Initialize
static void Initialize()
Definition: TypeSystemClang.cpp:639
lldb_private::TypeSystemClang::IsCStringType
bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) override
Definition: TypeSystemClang.cpp:2986
lldb_private::TypeSystemClang::CompleteObjCInterfaceDecl
void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *)
Definition: TypeSystemClang.cpp:9300
lldb_private::Expression::ResultType
ResultType
Definition: Expression.h:35
lldb_private::TypeSystemClang::ConvertAccessTypeToAccessSpecifier
static clang::AccessSpecifier ConvertAccessTypeToAccessSpecifier(lldb::AccessType access)
Definition: TypeSystemClang.cpp:440
Target.h
lldb_private::ScratchTypeSystemClang::~ScratchTypeSystemClang
~ScratchTypeSystemClang() override=default
lldb_private::TypeSystemClang::CreateStructForIdentifier
CompilerType CreateStructForIdentifier(ConstString type_name, const std::initializer_list< std::pair< const char *, CompilerType >> &type_fields, bool packed=false)
Definition: TypeSystemClang.cpp:2269
lldb_private::TypeSystemClang::m_module_map_up
std::unique_ptr< clang::ModuleMap > m_module_map_up
Definition: TypeSystemClang.h:1068
lldb_private::TypeSystemClang::GetBasicTypeFromAST
CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override
Definition: TypeSystemClang.cpp:4660
lldb_private::OptionalClangModuleID::m_id
unsigned m_id
Definition: TypeSystemClang.h:57
lldb_private::TypeSystemClang::DeclContextGetAsFunctionDecl
static clang::FunctionDecl * DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc)
Definition: TypeSystemClang.cpp:9717
lldb_private::TypeSystemClang::DumpDeclContextHiearchy
static void DumpDeclContextHiearchy(clang::DeclContext *decl_ctx)
Definition: TypeSystemClang.cpp:2387
lldb_private::ScratchTypeSystemClang::m_isolated_asts
std::unordered_map< IsolatedASTKey, std::unique_ptr< TypeSystemClang > > m_isolated_asts
Map from IsolatedASTKind to their actual TypeSystemClang instance.
Definition: TypeSystemClang.h:1229
lldb_private::TypeSystemClang::m_sema
clang::Sema * m_sema
The sema associated that is currently used to build this ASTContext.
Definition: TypeSystemClang.h:1096
lldb_private::TypeSystemClang::GetMinimumLanguage
lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4009
lldb_private::TypeSystemClang::m_display_name
std::string m_display_name
A string describing what this TypeSystemClang represents (e.g., AST for debug information,...
Definition: TypeSystemClang.h:1077
lldb_private::TypeSystemClang::CreateTypedef
CompilerType CreateTypedef(lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx, uint32_t opaque_payload) override
Using the current type, create a new typedef to that type using "typedef_name" as the name and "decl_...
Definition: TypeSystemClang.cpp:4605
lldb_private::TypeSystemClang::CompleteTagDecl
void CompleteTagDecl(clang::TagDecl *)
Definition: TypeSystemClang.cpp:9291
lldb_private::TypeSystemClang::m_source_manager_up
std::unique_ptr< clang::SourceManager > m_source_manager_up
Definition: TypeSystemClang.h:1059
lldb_private::TypeSystemClang::getMangleContext
clang::MangleContext * getMangleContext()
Definition: TypeSystemClang.cpp:763
lldb_private::TypeSystemClang::operator=
const TypeSystemClang & operator=(const TypeSystemClang &)
lldb_private::TypeSystemClang::GetFloatTypeFromBitSize
static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast, size_t bit_size)
lldb_private::TypeSystemClang::DeclContextGetAsNamespaceDecl
static clang::NamespaceDecl * DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc)
Definition: TypeSystemClang.cpp:9725
lldb_private::TypeSystemClang::DeclContextGetAsObjCMethodDecl
static clang::ObjCMethodDecl * DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc)
Definition: TypeSystemClang.cpp:9701
lldb_private::TypeSystemClang::IsCXXClassType
static bool IsCXXClassType(const CompilerType &type)
Definition: TypeSystemClang.cpp:3712
lldb_private::TypeSystemClang::GetAsCXXRecordDecl
static clang::CXXRecordDecl * GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:7260
lldb_private::ScratchTypeSystemClang::Finalize
void Finalize() override
Definition: TypeSystemClang.cpp:9791
lldb_private::TypeSystemClang::IsCharType
bool IsCharType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:2967
lldb_private::TypeSystemClang::DeclContextGetTypeSystemClang
static clang::ASTContext * DeclContextGetTypeSystemClang(const CompilerDeclContext &dc)
Definition: TypeSystemClang.cpp:9740
Log.h
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::TypeSystemClang::IsObjCObjectOrInterfaceType
static bool IsObjCObjectOrInterfaceType(const CompilerType &type)
Definition: TypeSystemClang.cpp:3487
lldb_private::TypeSystemClang::GetFunctionReturnType
CompilerType GetFunctionReturnType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4332
lldb_private::TypeSystemClang::CreateClassTemplateDecl
clang::ClassTemplateDecl * CreateClassTemplateDecl(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, lldb::AccessType access_type, llvm::StringRef class_name, int kind, const TemplateParameterInfos &infos)
Definition: TypeSystemClang.cpp:1567
lldb_private::TypeSystemClang::GetFormat
lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:5138
lldb_private::TypeSystemClang::AddFieldToRecordType
static clang::FieldDecl * AddFieldToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &field_type, lldb::AccessType access, uint32_t bitfield_bit_size)
Definition: TypeSystemClang.cpp:7274
lldb_private::TypeSystemClang::GetFunctionArgumentCount
int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4306
lldb_private::TypeSystemClang::GetCStringType
CompilerType GetCStringType(bool is_const)
Definition: TypeSystemClang.cpp:1159
lldb_private::ScratchTypeSystemClang::Dump
void Dump(llvm::raw_ostream &output) override
Definition: TypeSystemClang.cpp:9826
lldb_private::TypeSystemClang::IsOperator
static bool IsOperator(llvm::StringRef name, clang::OverloadedOperatorKind &op_kind)
Definition: TypeSystemClang.cpp:359
lldb_private::TypeSystemClang::CreateASTContext
void CreateASTContext()
Creates the internal ASTContext.
Definition: TypeSystemClang.cpp:713
lldb_private::TypeSystemClang::SetMetadata
void SetMetadata(const clang::Decl *object, ClangASTMetadata &meta_data)
Definition: TypeSystemClang.cpp:2556
lldb_private::TypeSystemClang::TemplateParameterInfos::hasParameterPack
bool hasParameterPack() const
Definition: TypeSystemClang.h:333
lldb_private::TypeSystemClang::SetObjCSuperClass
static bool SetObjCSuperClass(const CompilerType &type, const CompilerType &superclass_compiler_type)
Definition: TypeSystemClang.cpp:7798
lldb_private::TypeSystemClang::GetNumMemberFunctions
size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4344
ClangPersistentVariables.h
lldb_private::TypeSystemClang::GetFunctionArgumentTypeAtIndex
CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override
Definition: TypeSystemClang.cpp:4317
lldb_private::TypeSystemClang::ForEachEnumerator
void ForEachEnumerator(lldb::opaque_compiler_type_t type, std::function< bool(const CompilerType &integer_type, ConstString name, const llvm::APSInt &value)> const &callback) override
Definition: TypeSystemClang.cpp:5551
lldb_private::TypeSystemClang::getDisplayName
llvm::StringRef getDisplayName() const
Returns the display name of this TypeSystemClang that indicates what purpose it serves in LLDB.
Definition: TypeSystemClang.h:158
lldb_private::ScratchTypeSystemClang::classof
static bool classof(const TypeSystem *ts)
Definition: TypeSystemClang.h:1202
lldb_private::TypeSystemClang::GetDWARFParser
DWARFASTParser * GetDWARFParser() override
Definition: TypeSystemClang.cpp:9310
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::TypeSystemClang::GetTypeForDecl
CompilerType GetTypeForDecl(clang::NamedDecl *decl)
Definition: TypeSystemClang.cpp:1206
lldb_private::TypeSystemClang::GetNumTemplateArguments
size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:7099
lldb_private::TypeSystemClang::IsObjCClassTypeAndHasIVars
static bool IsObjCClassTypeAndHasIVars(const CompilerType &type, bool check_superclass)
Definition: TypeSystemClang.cpp:8026
lldb::eDescriptionLevelFull
@ eDescriptionLevelFull
Definition: lldb-enumerations.h:209
lldb-enumerations.h
lldb_private::ScratchTypeSystemClang::GetUserExpression
UserExpression * GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj) override
Definition: TypeSystemClang.cpp:9848
lldb_private::TypeSystemClang::SetTargetTriple
void SetTargetTriple(llvm::StringRef target_triple)
Definition: TypeSystemClang.cpp:675
lldb_private::TypeSystemClang::GetTypeBitAlign
llvm::Optional< size_t > GetTypeBitAlign(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override
Definition: TypeSystemClang.cpp:4745
lldb_private::TypeSystemClang::GetNumFields
uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:5577
lldb_private::TypeSystemClang::GetOrCreateStructForIdentifier
CompilerType GetOrCreateStructForIdentifier(ConstString type_name, const std::initializer_list< std::pair< const char *, CompilerType >> &type_fields, bool packed=false)
Definition: TypeSystemClang.cpp:2295
lldb_private::ScratchTypeSystemClang::GetForTarget
static TypeSystemClang * GetForTarget(Target &target, const clang::LangOptions &lang_opts)
Returns the scratch TypeSystemClang for the given target.
Definition: TypeSystemClang.h:1168
lldb_private::TypeSystemClang::CheckOverloadedOperatorKindParameterCount
static bool CheckOverloadedOperatorKindParameterCount(bool is_method, clang::OverloadedOperatorKind op_kind, uint32_t num_params)
Definition: TypeSystemClang.cpp:1725
lldb_private::TypeSystemClang::CreateClassTemplateSpecializationType
CompilerType CreateClassTemplateSpecializationType(clang::ClassTemplateSpecializationDecl *class_template_specialization_decl)
Definition: TypeSystemClang.cpp:1697
lldb_private::TypeSystemClang::DeclGetFunctionArgumentType
CompilerType DeclGetFunctionArgumentType(void *opaque_decl, size_t arg_idx) override
Definition: TypeSystemClang.cpp:9412
lldb_private::TypeSystemClang::IsIntegerType
bool IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed) override
Definition: TypeSystemClang.cpp:3208
lldb_private::TypeSystemClang::GetTypeQualifiers
unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4223
lldb_private::TypeSystemClang::m_identifier_table_up
std::unique_ptr< clang::IdentifierTable > m_identifier_table_up
Definition: TypeSystemClang.h:1064
lldb_private::TypeSystemClang::AddObjCClassProperty
static bool AddObjCClassProperty(const CompilerType &type, const char *property_name, const CompilerType &property_compiler_type, clang::ObjCIvarDecl *ivar_decl, const char *property_setter_name, const char *property_getter_name, uint32_t property_attributes, ClangASTMetadata *metadata)
Definition: TypeSystemClang.cpp:7821
lldb_private::TypeSystemClang::TemplateParameterInfos::IsValid
bool IsValid() const
Definition: TypeSystemClang.h:324
lldb_private::ScratchTypeSystemClang::CreateUtilityFunction
std::unique_ptr< UtilityFunction > CreateUtilityFunction(std::string text, std::string name) override
Definition: TypeSystemClang.cpp:9876
lldb_private::TypeSystemClang::GetUniqueNamespaceDeclaration
clang::NamespaceDecl * GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, bool is_inline=false)
Definition: TypeSystemClang.cpp:1857
lldb_private::TypeSystemClang::GetLValueReferenceType
CompilerType GetLValueReferenceType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4554
lldb_private::TypeSystemClang::GetPointerType
CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4537
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::TypeSystemClang::TemplateParameterInfos::pack_name
const char * pack_name
Definition: TypeSystemClang.h:338
lldb_private::ScratchTypeSystemClang::GetIsolatedAST
TypeSystemClang & GetIsolatedAST(IsolatedASTKind feature)
Returns the requested sub-AST.
Definition: TypeSystemClang.cpp:9916
lldb_private::TypeSystemClang::GetBuiltinTypeForDWARFEncodingAndBitSize
CompilerType GetBuiltinTypeForDWARFEncodingAndBitSize(llvm::StringRef type_name, uint32_t dw_ate, uint32_t bit_size)
Definition: TypeSystemClang.cpp:941
lldb_private::ConstString::GetLength
size_t GetLength() const
Get the length in bytes of string value.
Definition: ConstString.cpp:237
lldb_private::ClangASTMetadata
Definition: ClangASTMetadata.h:18
lldb_private::TypeSystemClang::GetPluginName
llvm::StringRef GetPluginName() override
Definition: TypeSystemClang.h:140
lldb_private::TypeSystemClang::IsEnumerationType
bool IsEnumerationType(lldb::opaque_compiler_type_t type, bool &is_signed) override
Definition: TypeSystemClang.cpp:3227
TypeSystem.h
lldb_private::TypeSystemClang::GetAsDeclContext
static clang::DeclContext * GetAsDeclContext(clang::FunctionDecl *function_decl)
lldb_private::TypeSystemClang::m_diagnostics_engine_up
std::unique_ptr< clang::DiagnosticsEngine > m_diagnostics_engine_up
Definition: TypeSystemClang.h:1060
lldb::TemplateArgumentKind
TemplateArgumentKind
Definition: lldb-enumerations.h:821
CompilerType.h
lldb_private::TypeSystemClang::CountDeclLevels
uint32_t CountDeclLevels(clang::DeclContext *frame_decl_ctx, clang::DeclContext *child_decl_ctx, ConstString *child_name=nullptr, CompilerType *child_type=nullptr)
Definition: TypeSystemClang.cpp:9529
lldb_private::TypeSystemClang::GetOrCreateClangModule
OptionalClangModuleID GetOrCreateClangModule(llvm::StringRef name, OptionalClangModuleID parent, bool is_framework=false, bool is_explicit=false)
Synthesize a clang::Module and return its ID or a default-constructed ID.
Definition: TypeSystemClang.cpp:1236
lldb_private::TypeSystemClang::m_cxx_record_decl_access
CXXRecordDeclAccessMap m_cxx_record_decl_access
Maps CXXRecordDecl to their most recent added method/field's AccessSpecifier.
Definition: TypeSystemClang.h:1091
lldb_private::TypeSystemClang::SetOwningModule
static void SetOwningModule(clang::Decl *decl, OptionalClangModuleID owning_module)
Set the owning module for decl.
Definition: TypeSystemClang.cpp:1225
lldb_private::TypeSystemClang::GetAsObjCInterfaceDecl
static clang::ObjCInterfaceDecl * GetAsObjCInterfaceDecl(const CompilerType &type)
Definition: TypeSystemClang.cpp:7265
lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition: CompilerDeclContext.h:30
lldb_private::TypeSystemClang::SetIsPacked
static void SetIsPacked(const CompilerType &type)
Definition: TypeSystemClang.cpp:7478
lldb_private::TypeSystemClang::GetCXXRecordDeclAccess
clang::AccessSpecifier GetCXXRecordDeclAccess(const clang::CXXRecordDecl *object)
Definition: TypeSystemClang.cpp:2589
lldb_private::TypePayloadClang::TypePayloadClang
TypePayloadClang(uint32_t opaque_payload)
Definition: TypeSystemClang.h:79
lldb_private::TypeSystemClang::GetTypeInfo
uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type) override
Definition: TypeSystemClang.cpp:3808
lldb_private::TypeSystemClang::GetType
CompilerType GetType(clang::QualType qt)
Creates a CompilerType form the given QualType with the current TypeSystemClang instance as the Compi...
Definition: TypeSystemClang.h:237
lldb_private::ScratchTypeSystemClang::InferIsolatedASTKindFromLangOpts
static llvm::Optional< IsolatedASTKind > InferIsolatedASTKindFromLangOpts(const clang::LangOptions &l)
Infers the appropriate sub-AST from Clang's LangOptions.
Definition: TypeSystemClang.h:1139
lldb_private::TypeSystemClang::getTargetInfo
clang::TargetInfo * getTargetInfo()
Definition: TypeSystemClang.cpp:778
lldb_private::TypeSystemClang::IsVectorType
bool IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) override
Definition: TypeSystemClang.cpp:2914
lldb_private::TypeSystemClang::AddMethodOverridesForCXXRecordType
void AddMethodOverridesForCXXRecordType(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:7756
lldb_private::ScratchTypeSystemClang::IsolatedASTKind
IsolatedASTKind
The different kinds of isolated ASTs within the scratch TypeSystem.
Definition: TypeSystemClang.h:1124
lldb_private::TypeSystemClang::DumpSummary
void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size) override
Definition: TypeSystemClang.cpp:9051
lldb_private::TypeSystemClang::GetTypeForFormatters
CompilerType GetTypeForFormatters(void *type) override
Definition: TypeSystemClang.cpp:7224
lldb_private::TypeSystemClang::GetTypedefedType
CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4648
lldb_private::TypeSystemClang::GetAsTemplateSpecialization
const clang::ClassTemplateSpecializationDecl * GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:7128
lldb_private::TypeSystemClang::SetFunctionParameters
void SetFunctionParameters(clang::FunctionDecl *function_decl, llvm::ArrayRef< clang::ParmVarDecl * > params)
Definition: TypeSystemClang.cpp:2228
lldb_private::TypeSystemClang::GetOpaqueCompilerType
static lldb::opaque_compiler_type_t GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType basic_type)
Definition: TypeSystemClang.cpp:2008
lldb_private::TypeSystemClang::UnifyAccessSpecifiers
static clang::AccessSpecifier UnifyAccessSpecifiers(clang::AccessSpecifier lhs, clang::AccessSpecifier rhs)
Definition: TypeSystemClang.cpp:1751
lldb_private::ScratchTypeSystemClang::ForgetSource
void ForgetSource(clang::ASTContext *src_ctx, ClangASTImporter &importer)
Unregisters the given ASTContext as a source from the scratch AST (and all sub-ASTs).
Definition: TypeSystemClang.cpp:9892
lldb_private::TypeSystemClang::AreTypesSame
static bool AreTypesSame(CompilerType type1, CompilerType type2, bool ignore_qualifiers=false)
Definition: TypeSystemClang.cpp:1169
lldb_private::TypeSystemClang::GetIndexOfChildWithName
uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) override
Definition: TypeSystemClang.cpp:6904
lldb_private::TypeSystemClang::IsFloatingPointType
bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) override
Definition: TypeSystemClang.cpp:3410
lldb_private::TypeSystemClang::SetCXXRecordDeclAccess
void SetCXXRecordDeclAccess(const clang::CXXRecordDecl *object, clang::AccessSpecifier access)
Definition: TypeSystemClang.cpp:2580
DWARFASTParserClang
Definition: DWARFASTParserClang.h:37
lldb_private::TypeSystemClang::GetRValueReferenceType
CompilerType GetRValueReferenceType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4562
lldb_private::TypeSystemClang::ParseClassTemplateDecl
clang::ClassTemplateDecl * ParseClassTemplateDecl(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, lldb::AccessType access_type, const char *parent_name, int tag_decl_kind, const TypeSystemClang::TemplateParameterInfos &template_param_infos)
Definition: TypeSystemClang.cpp:9276
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::TypeSystemClang::RecordHasFields
static bool RecordHasFields(const clang::RecordDecl *record_decl)
Definition: TypeSystemClang.cpp:1783
lldb_private::ScratchTypeSystemClang
The TypeSystemClang instance used for the scratch ASTContext in a lldb::Target.
Definition: TypeSystemClang.h:1108
lldb_private::OptionalClangModuleID
A Clang module ID.
Definition: TypeSystemClang.h:56
lldb_private::TypeSystemClang::GetAsTypedefDecl
static clang::TypedefNameDecl * GetAsTypedefDecl(const CompilerType &type)
Definition: TypeSystemClang.cpp:7251
uint32_t
DWARFASTParser
Definition: DWARFASTParser.h:26
lldb_private::TypeSystemClang::GetCompleteDecl
bool GetCompleteDecl(clang::Decl *decl)
Definition: TypeSystemClang.h:177
lldb_private::TypeSystemClang::CompleteTagDeclCallback
void(* CompleteTagDeclCallback)(void *baton, clang::TagDecl *)
Definition: TypeSystemClang.h:110
lldb_private::Type::Payload
uint32_t Payload
Definition: Type.h:214
lldb_private::CompilerType::SetCompilerType
void SetCompilerType(TypeSystem *type_system, lldb::opaque_compiler_type_t type)
Definition: CompilerType.cpp:312
lldb_private::TypeSystemClang::GetEnumerationIntegerType
CompilerType GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4300
lldb_private::TypeSystemClang::CreateMemberPointerType
static CompilerType CreateMemberPointerType(const CompilerType &type, const CompilerType &pointee_type)
Definition: TypeSystemClang.cpp:8400
lldb_private::Address
Definition: Address.h:59
lldb_private::ScratchTypeSystemClang::ID
static char ID
LLVM RTTI support.
Definition: TypeSystemClang.h:1110
id
void * id
Definition: PlatformiOSSimulatorCoreSimulatorSupport.h:20
lldb_private::TypeSystemClang::CreateVariableDeclaration
clang::VarDecl * CreateVariableDeclaration(clang::DeclContext *decl_context, OptionalClangModuleID owning_module, const char *name, clang::QualType type)
Definition: TypeSystemClang.cpp:1989
PDBASTParser
Definition: PDBASTParser.h:43
lldb_private::TypeSystemClang::DumpValue
void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary, bool verbose, uint32_t depth) override
Definition: TypeSystemClang.cpp:8473
lldb_private::TypePayloadClang::IsCompleteObjCClass
bool IsCompleteObjCClass()
Definition: TypeSystemClang.h:83
lldb_private::TypeSystemClang::DeclMetadataMap
llvm::DenseMap< const clang::Decl *, ClangASTMetadata > DeclMetadataMap
Definition: TypeSystemClang.h:1079
lldb_private::TypeSystemClang::DeclGetFunctionNumArguments
size_t DeclGetFunctionNumArguments(void *opaque_decl) override
Definition: TypeSystemClang.cpp:9401
lldb_private::TypeSystemClang::IsDefined
bool IsDefined(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3448
lldb_private::TypeSystemClang::GetCompleteType
bool GetCompleteType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3760
lldb_private::TypeSystemClang::GetSupportedLanguagesForTypes
static LanguageSet GetSupportedLanguagesForTypes()
Definition: TypeSystemClang.cpp:613
lldb_private::TypeSystemClang::CreateFunctionTemplateDecl
clang::FunctionTemplateDecl * CreateFunctionTemplateDecl(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, clang::FunctionDecl *func_decl, const TemplateParameterInfos &infos)
Definition: TypeSystemClang.cpp:1432
lldb_private::TypePayloadClang::SetOwningModule
void SetOwningModule(OptionalClangModuleID id)
Definition: TypeSystemClang.cpp:329
lldb_private::TypeSystemClang::BuildIndirectFields
static void BuildIndirectFields(const CompilerType &type)
Definition: TypeSystemClang.cpp:7370
lldb_private::TypeSystemClang::GetAsRecordDecl
static clang::RecordDecl * GetAsRecordDecl(const CompilerType &type)
Definition: TypeSystemClang.cpp:7238
lldb_private::TypeSystemClang::IsHomogeneousAggregate
uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr) override
Definition: TypeSystemClang.cpp:3038
lldb_private::TypeSystemClang::m_header_search_up
std::unique_ptr< clang::HeaderSearch > m_header_search_up
Definition: TypeSystemClang.h:1067
lldb_private::TypeSystemClang::GetNumVirtualBaseClasses
uint32_t GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:5849
lldb_private::TypeSystemClang::GetByteSize
llvm::Optional< uint64_t > GetByteSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
Definition: TypeSystemClang.h:727
lldb_private::TypeSystemClang::dump
LLVM_DUMP_METHOD void dump(lldb::opaque_compiler_type_t type) const override
Convenience LLVM-style dump method for use in the debugger only.
Definition: TypeSystemClang.cpp:8420
lldb_private::ScratchTypeSystemClang::GetForTarget
static TypeSystemClang * GetForTarget(Target &target, llvm::Optional< IsolatedASTKind > ast_kind=DefaultAST, bool create_on_demand=true)
Returns the scratch TypeSystemClang for the given target.
Definition: TypeSystemClang.cpp:9797
lldb_private::TypeSystemClang::GetFunctionArgumentAtIndex
CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index) override
Definition: TypeSystemClang.cpp:3132
lldb_private::TypeSystemClang::CanPassInRegisters
bool CanPassInRegisters(const CompilerType &type) override
Definition: TypeSystemClang.cpp:3684
lldb::Encoding
Encoding
Register encoding definitions.
Definition: lldb-enumerations.h:146
lldb_private::ClangASTImporter
Manages and observes all Clang AST node importing in LLDB.
Definition: ClangASTImporter.h:64
lldb_private::TypeSystemClang::IsBlockPointerType
bool IsBlockPointerType(lldb::opaque_compiler_type_t type, CompilerType *function_pointer_type_ptr) override
Definition: TypeSystemClang.cpp:3171
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb_private::TypeSystemClang::DeclContextGetName
ConstString DeclContextGetName(void *opaque_decl_ctx) override
Definition: TypeSystemClang.cpp:9611
lldb_private::TypeSystemClang::CreateRecordType
CompilerType CreateRecordType(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, lldb::AccessType access_type, llvm::StringRef name, int kind, lldb::LanguageType language, ClangASTMetadata *metadata=nullptr, bool exports_symbols=false)
Definition: TypeSystemClang.cpp:1270
clang
Definition: ASTResultSynthesizer.h:15
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::TypeSystemClang::IsTypedefType
bool IsTypedefType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3671
lldb_private::TypeSystemClang::~TypeSystemClang
~TypeSystemClang() override
Definition: TypeSystemClang.cpp:573
lldb_private::TypeSystemClang::GetBasicTypeEnumeration
static lldb::BasicType GetBasicTypeEnumeration(ConstString name)
Definition: TypeSystemClang.cpp:856
lldb_private::TypeSystemClang::DumpTypeName
static void DumpTypeName(const CompilerType &type)
Definition: TypeSystemClang.cpp:9204
lldb_private::TypeSystemClang::TypeMetadataMap
llvm::DenseMap< const clang::Type *, ClangASTMetadata > TypeMetadataMap
Definition: TypeSystemClang.h:1083
lldb_private::TypeSystemClang::TemplateParameterInfos::args
llvm::SmallVector< clang::TemplateArgument, 2 > args
Definition: TypeSystemClang.h:336
lldb_private::TypeSystemClang::DeclContextIsClassMethod
bool DeclContextIsClassMethod(void *opaque_decl_ctx, lldb::LanguageType *language_ptr, bool *is_instance_method_ptr, ConstString *language_object_name_ptr) override
Definition: TypeSystemClang.cpp:9632
lldb_private::PersistentExpressionState
Definition: ExpressionVariable.h:203
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb_private::TypeSystemClang::StartTagDeclarationDefinition
static bool StartTagDeclarationDefinition(const CompilerType &type)
Definition: TypeSystemClang.cpp:8221
lldb_private::TypeSystemClang::IsVoidType
bool IsVoidType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3678
lldb_private::TypeSystemClang::IsAggregateType
bool IsAggregateType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:2802
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::TypeSystemClang::DeclGetFunctionReturnType
CompilerType DeclGetFunctionReturnType(void *opaque_decl) override
Definition: TypeSystemClang.cpp:9390
lldb_private::TypeSystemClang::GetLangOpts
clang::LangOptions * GetLangOpts() const
Definition: TypeSystemClang.h:1036
lldb_private::TypeSystemClang::DeclContextGetAsDeclContext
static clang::DeclContext * DeclContextGetAsDeclContext(const CompilerDeclContext &dc)
Definition: TypeSystemClang.cpp:9694
lldb_private::OptionalClangModuleID::OptionalClangModuleID
OptionalClangModuleID()=default
lldb_private::ScratchTypeSystemClang::m_persistent_variables
std::unique_ptr< ClangPersistentVariables > m_persistent_variables
The persistent variables associated with this process for the expression parser.
Definition: TypeSystemClang.h:1217
lldb_private::TypeSystemClang::GetTypeName
ConstString GetTypeName(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3768
lldb_private::TypeSystemClang::m_decl_metadata
DeclMetadataMap m_decl_metadata
Maps Decls to their associated ClangASTMetadata.
Definition: TypeSystemClang.h:1081
lldb_private::TypeSystemClang::IsPolymorphicClass
bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3509
lldb_private::TypeSystem
Interface for representing a type system.
Definition: TypeSystem.h:71
lldb_private::TypeSystemClang::GetSourceMgr
clang::SourceManager * GetSourceMgr() const
Definition: TypeSystemClang.h:1039
lldb_private::TypeSystemClang::IsRuntimeGeneratedType
bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:2949
lldb_private::TypeSystemClang::m_type_metadata
TypeMetadataMap m_type_metadata
Maps Types to their associated ClangASTMetadata.
Definition: TypeSystemClang.h:1085
lldb_private::TypeSystemClang::GetDisplayTypeName
ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3794
lldb_private::TypeSystemClang::SetIntegerInitializerForVariable
static void SetIntegerInitializerForVariable(clang::VarDecl *var, const llvm::APInt &init_value)
Initializes a variable with an integer value.
Definition: TypeSystemClang.cpp:7531
lldb_private::TypeSystemClang::setSema
void setSema(clang::Sema *s)
Definition: TypeSystemClang.cpp:665
lldb_private::TypeSystemClang::FieldIsBitfield
bool FieldIsBitfield(clang::FieldDecl *field, uint32_t &bitfield_bit_size)
Definition: TypeSystemClang.cpp:1764
lldb_private::TypeSystemClang::GetBasicType
CompilerType GetBasicType(lldb::BasicType type)
Definition: TypeSystemClang.cpp:930
lldb_private::TypeSystemClang::GetBitSize
llvm::Optional< uint64_t > GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override
Definition: TypeSystemClang.cpp:4681
lldb_private::TypeSystemClang::GetTypeTemplateArgument
CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx) override
Definition: TypeSystemClang.cpp:7192
lldb_private::TypeSystemClang::GetPointeeType
CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4528
lldb_private::TypeSystemClang::CreateUsingDirectiveDeclaration
clang::UsingDirectiveDecl * CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, clang::NamespaceDecl *ns_decl)
Definition: TypeSystemClang.cpp:1951
lldb_private::Flags::Set
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
lldb_private::TypeSystemClang::getTargetOptions
std::shared_ptr< clang::TargetOptions > & getTargetOptions()
Definition: TypeSystemClang.cpp:769
lldb_private::TypeSystemClang
A TypeSystem implementation based on Clang.
Definition: TypeSystemClang.h:105
ConstString.h
lldb_private::TypeSystemClang::IsPointerType
bool IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override
Definition: TypeSystemClang.cpp:3257
Flags.h
lldb_private::TypeSystemClang::TypeSystemClang
TypeSystemClang(llvm::StringRef name, llvm::Triple triple)
Constructs a TypeSystemClang with an ASTContext using the given triple.
Definition: TypeSystemClang.cpp:553
lldb_private::TypeSystemClang::AddEnumerationValueToEnumerationType
clang::EnumConstantDecl * AddEnumerationValueToEnumerationType(const CompilerType &enum_type, const Declaration &decl, const char *name, int64_t enum_value, uint32_t enum_value_bit_size)
Definition: TypeSystemClang.cpp:8376
lldb_private::LanguageSet
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
Definition: TypeSystem.h:40
lldb_private::TypeSystemClang::GetFieldAtIndex
CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) override
Definition: TypeSystemClang.cpp:5694
lldb_private::TypeSystemClang::GetCXXClassName
static llvm::Optional< std::string > GetCXXClassName(const CompilerType &type)
Definition: TypeSystemClang.cpp:3697
lldb_private::TypeSystemClang::IsScopedEnumerationType
bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3243
lldb_private::ScratchTypeSystemClang::GetFunctionCaller
FunctionCaller * GetFunctionCaller(const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name) override
Definition: TypeSystemClang.cpp:9860
lldb_private::TypeSystemClang::isA
bool isA(const void *ClassID) const override
Definition: TypeSystemClang.h:115
lldb_private::TypeSystemClang::SetHasExternalStorage
static bool SetHasExternalStorage(lldb::opaque_compiler_type_t type, bool has_extern)
Definition: TypeSystemClang.cpp:8168
lldb_private::TypeSystemClang::TemplateParameterInfos
Definition: TypeSystemClang.h:322
lldb_private::ScratchTypeSystemClang::CreateASTSource
std::unique_ptr< ClangASTSource > CreateASTSource()
Definition: TypeSystemClang.cpp:9901
lldb_private::TypeSystemClang::Finalize
void Finalize() override
Definition: TypeSystemClang.cpp:649
lldb_private::TypeSystemClang::SupportsLanguage
bool SupportsLanguage(lldb::LanguageType language) override
Definition: TypeSystemClang.cpp:3692
lldb_private::TypeSystemClang::DumpFromSymbolFile
void DumpFromSymbolFile(Stream &s, llvm::StringRef symbol_name)
Dump clang AST types from the symbol file.
Definition: TypeSystemClang.cpp:8432
lldb_private::TypeSystemClang::AddMethodToCXXRecordType
clang::CXXMethodDecl * AddMethodToCXXRecordType(lldb::opaque_compiler_type_t type, llvm::StringRef name, const char *mangled_name, const CompilerType &method_type, lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline, bool is_explicit, bool is_attr_used, bool is_artificial)
Definition: TypeSystemClang.cpp:7560
lldb_private::TypeSystemClang::GetCanonicalType
CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4266
lldb_private::TypeSystemClang::Dump
void Dump(llvm::raw_ostream &output) override
Definition: TypeSystemClang.cpp:8428
lldb_private::TypeMemberFunctionImpl
Definition: Type.h:438
lldb_private::ScratchTypeSystemClang::m_target_wp
lldb::TargetWP m_target_wp
Definition: TypeSystemClang.h:1214
lldb_private::TypeSystemClang::AddMethodToObjCObjectType
static clang::ObjCMethodDecl * AddMethodToObjCObjectType(const CompilerType &type, const char *name, const CompilerType &method_compiler_type, lldb::AccessType access, bool is_artificial, bool is_variadic, bool is_objc_direct_call)
Definition: TypeSystemClang.cpp:8034
lldb_private::TypeSystemClang::GetDeclContextForType
static clang::DeclContext * GetDeclContextForType(clang::QualType type)
Definition: TypeSystemClang.cpp:2635
lldb_private::TypePayloadClang::m_payload
Type::Payload m_payload
The Layout is as follows:
Definition: TypeSystemClang.h:73
lldb_private::TypeSystemClang::IsFunctionType
bool IsFunctionType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3011
lldb_private::TypeSystemClang::IsEnumType
static bool IsEnumType(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:3501
lldb_private::TypeSystemClang::CXXRecordDeclAccessMap
llvm::DenseMap< const clang::CXXRecordDecl *, clang::AccessSpecifier > CXXRecordDeclAccessMap
Definition: TypeSystemClang.h:1088
lldb_private::TypeSystemClang::ID
static char ID
Definition: TypeSystemClang.h:107
lldb_private::TypeSystemClang::GetVirtualBaseClassAtIndex
CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override
Definition: TypeSystemClang.cpp:5964
lldb_private::Declaration
Definition: Declaration.h:24
lldb_private::TypeSystemClang::m_mangle_ctx_up
std::unique_ptr< clang::MangleContext > m_mangle_ctx_up
Definition: TypeSystemClang.h:1071
lldb_private::TypeSystemClang::CreateUsingDeclaration
clang::UsingDecl * CreateUsingDeclaration(clang::DeclContext *current_decl_ctx, OptionalClangModuleID owning_module, clang::NamedDecl *target)
Definition: TypeSystemClang.cpp:1970
lldb_private::TypeSystemClang::AddConstModifier
CompilerType AddConstModifier(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4576
lldb_private::TypeSystemClang::Terminate
static void Terminate()
Definition: TypeSystemClang.cpp:645
lldb_private::TypeSystemClang::CreateClassTemplateSpecializationDecl
clang::ClassTemplateSpecializationDecl * CreateClassTemplateSpecializationDecl(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, clang::ClassTemplateDecl *class_template_decl, int kind, const TemplateParameterInfos &infos)
Definition: TypeSystemClang.cpp:1663
lldb_private::TypeSystemClang::classof
static bool classof(const TypeSystem *ts)
Definition: TypeSystemClang.h:116
lldb_private::TypeSystemClang::AddVolatileModifier
CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4586
lldb_private::TypeSystemClang::GetEncoding
lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) override
Definition: TypeSystemClang.cpp:4752
lldb_private::TypeSystemClang::CompleteTagDeclarationDefinition
static bool CompleteTagDeclarationDefinition(const CompilerType &type)
Definition: TypeSystemClang.cpp:8246
lldb_private::TypeSystemClang::GetPointerSizedIntType
CompilerType GetPointerSizedIntType(bool is_signed)
Definition: TypeSystemClang.cpp:2382
lldb_private::TypeSystemClang::IsBeingDefined
bool IsBeingDefined(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:3720
lldb_private::TypeSystemClang::GetTypeClass
lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4093
lldb_private::TypeSystemClang::CreateFunctionTemplateSpecializationInfo
void CreateFunctionTemplateSpecializationInfo(clang::FunctionDecl *func_decl, clang::FunctionTemplateDecl *Template, const TemplateParameterInfos &infos)
Definition: TypeSystemClang.cpp:1464
lldb_private::TypeSystemClang::IsClassType
static bool IsClassType(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:3493
lldb_private::TypeSystemClang::SetMetadataAsUserID
void SetMetadataAsUserID(const clang::Decl *decl, lldb::user_id_t user_id)
Definition: TypeSystemClang.cpp:2542
lldb::AccessType
AccessType
Definition: lldb-enumerations.h:507
lldb_private::TypeSystemClang::SetExternalSource
void SetExternalSource(llvm::IntrusiveRefCntPtr< clang::ExternalASTSource > &ast_source_up)
Definition: TypeSystemClang.cpp:679
lldb_private::TypeSystemClang::CreateBaseClassSpecifier
std::unique_ptr< clang::CXXBaseSpecifier > CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type, lldb::AccessType access, bool is_virtual, bool base_of_class)
Definition: TypeSystemClang.cpp:7766
lldb::opaque_compiler_type_t
void * opaque_compiler_type_t
Definition: lldb-types.h:90
lldb_private::TypeSystemClang::GetDeclarationName
clang::DeclarationName GetDeclarationName(llvm::StringRef name, const CompilerType &function_clang_type)
Definition: TypeSystemClang.cpp:2083
lldb_private::TypeSystemClang::GetQualType
static clang::QualType GetQualType(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.h:1019
lldb_private::TypeSystemClang::GetTypePrintingPolicy
clang::PrintingPolicy GetTypePrintingPolicy()
Returns the PrintingPolicy used when generating the internal type names.
Definition: TypeSystemClang.cpp:2109
lldb_private::TypeSystemClang::DumpDeclHiearchy
static void DumpDeclHiearchy(clang::Decl *decl)
Definition: TypeSystemClang.cpp:2401
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::TypeSystemClang::GetTargetTriple
const char * GetTargetTriple()
Definition: TypeSystemClang.cpp:671
lldb_private::TypeSystemClang::DeclGetDeclContext
CompilerDeclContext DeclGetDeclContext(void *opaque_decl) override
Definition: TypeSystemClang.cpp:9384
lldb_private::TypeSystemClang::Verify
bool Verify(lldb::opaque_compiler_type_t type) override
Verify the integrity of the type to catch CompilerTypes that mix and match invalid TypeSystem/Opaque ...
Definition: TypeSystemClang.cpp:2797
lldb_private::TypeSystemClang::GetChildCompilerTypeAtIndex
CompilerType GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name, uint32_t &child_byte_size, int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, bool &child_is_base_class, bool &child_is_deref_of_parent, ValueObject *valobj, uint64_t &language_flags) override
Definition: TypeSystemClang.cpp:6145
lldb_private::TypeSystemClang::DumpTypeDescription
void DumpTypeDescription(lldb::opaque_compiler_type_t type, lldb::DescriptionLevel level=lldb::eDescriptionLevelFull) override
Dump the type to stdout.
Definition: TypeSystemClang.cpp:9096
lldb_private::TypeSystemClang::DeclGetMangledName
ConstString DeclGetMangledName(void *opaque_decl) override
Definition: TypeSystemClang.cpp:9354
lldb_private::TypeSystemClang::IsObjCClassType
static bool IsObjCClassType(const CompilerType &type)
Definition: TypeSystemClang.cpp:3474
lldb_private::FunctionCaller
Definition: FunctionCaller.h:56
lldb_private::TypeSystemClang::CompleteObjCInterfaceDeclCallback
void(* CompleteObjCInterfaceDeclCallback)(void *baton, clang::ObjCInterfaceDecl *)
Definition: TypeSystemClang.h:111
lldb_private::TypeSystemClang::TemplateParameterInfos::names
llvm::SmallVector< const char *, 2 > names
Definition: TypeSystemClang.h:335
lldb_private::TypeSystemClang::TemplateParameterInfos::packed_args
std::unique_ptr< TemplateParameterInfos > packed_args
Definition: TypeSystemClang.h:339
lldb_private::TypeSystemClang::GetMemberFunctionAtIndex
TypeMemberFunctionImpl GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override
Definition: TypeSystemClang.cpp:4404
lldb_private::TypeSystemClang::GetArrayElementType
CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override
Definition: TypeSystemClang.cpp:4232