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 <memory>
17#include <optional>
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/AST/Type.h"
27#include "clang/Basic/TargetInfo.h"
28#include "llvm/ADT/APSInt.h"
29#include "llvm/ADT/SmallVector.h"
30
31#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
32#include "lldb/Expression/ExpressionVariable.h"
33#include "lldb/Symbol/CompilerType.h"
34#include "lldb/Symbol/TypeSystem.h"
35#include "lldb/Target/Target.h"
36#include "lldb/Utility/ConstString.h"
37#include "lldb/Utility/Flags.h"
38#include "lldb/Utility/Log.h"
39#include "lldb/lldb-enumerations.h"
40
41class DWARFASTParserClang;
42class PDBASTParser;
43
44namespace clang {
45class FileManager;
46class HeaderSearch;
47class ModuleMap;
48} // namespace clang
49
50namespace lldb_private {
51
52class ClangASTMetadata;
53class ClangASTSource;
54class Declaration;
55
56/// A Clang module ID.
57class OptionalClangModuleID {
58 unsigned m_id = 0;
59
60public:
61 OptionalClangModuleID() = default;
62 explicit OptionalClangModuleID(unsigned id) : m_id(id) {}
63 bool HasValue() const { return m_id != 0; }
64 unsigned GetValue() const { return m_id; }
65};
66
67/// The implementation of lldb::Type's m_payload field for TypeSystemClang.
68class TypePayloadClang {
69 /// The Layout is as follows:
70 /// \verbatim
71 /// bit 0..30 ... Owning Module ID.
72 /// bit 31 ...... IsCompleteObjCClass.
73 /// \endverbatim
74 Type::Payload m_payload = 0;
75
76public:
77 TypePayloadClang() = default;
78 explicit TypePayloadClang(OptionalClangModuleID owning_module,
79 bool is_complete_objc_class = false);
80 explicit TypePayloadClang(uint32_t opaque_payload) : m_payload(opaque_payload) {}
81 operator Type::Payload() { return m_payload; }
82
83 static constexpr unsigned ObjCClassBit = 1 << 31;
84 bool IsCompleteObjCClass() { return Flags(m_payload).Test(bit: ObjCClassBit); }
85 void SetIsCompleteObjCClass(bool is_complete_objc_class) {
86 m_payload = is_complete_objc_class ? Flags(m_payload).Set(ObjCClassBit)
87 : Flags(m_payload).Clear(mask: ObjCClassBit);
88 }
89 OptionalClangModuleID GetOwningModule() {
90 return OptionalClangModuleID(Flags(m_payload).Clear(mask: ObjCClassBit));
91 }
92 void SetOwningModule(OptionalClangModuleID id);
93 /// \}
94};
95
96/// A TypeSystem implementation based on Clang.
97///
98/// This class uses a single clang::ASTContext as the backend for storing
99/// its types and declarations. Every clang::ASTContext should also just have
100/// a single associated TypeSystemClang instance that manages it.
101///
102/// The clang::ASTContext instance can either be created by TypeSystemClang
103/// itself or it can adopt an existing clang::ASTContext (for example, when
104/// it is necessary to provide a TypeSystem interface for an existing
105/// clang::ASTContext that was created by clang::CompilerInstance).
106class TypeSystemClang : public TypeSystem {
107 // LLVM RTTI support
108 static char ID;
109
110public:
111 typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);
112 typedef void (*CompleteObjCInterfaceDeclCallback)(void *baton,
113 clang::ObjCInterfaceDecl *);
114
115 // llvm casting support
116 bool isA(const void *ClassID) const override { return ClassID == &ID; }
117 static bool classof(const TypeSystem *ts) { return ts->isA(ClassID: &ID); }
118
119 /// Constructs a TypeSystemClang with an ASTContext using the given triple.
120 ///
121 /// \param name The name for the TypeSystemClang (for logging purposes)
122 /// \param triple The llvm::Triple used for the ASTContext. The triple defines
123 /// certain characteristics of the ASTContext and its types
124 /// (e.g., whether certain primitive types exist or what their
125 /// signedness is).
126 explicit TypeSystemClang(llvm::StringRef name, llvm::Triple triple);
127
128 /// Constructs a TypeSystemClang that uses an existing ASTContext internally.
129 /// Useful when having an existing ASTContext created by Clang.
130 ///
131 /// \param name The name for the TypeSystemClang (for logging purposes)
132 /// \param existing_ctxt An existing ASTContext.
133 explicit TypeSystemClang(llvm::StringRef name,
134 clang::ASTContext &existing_ctxt);
135
136 ~TypeSystemClang() override;
137
138 void Finalize() override;
139
140 // PluginInterface functions
141 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
142
143 static llvm::StringRef GetPluginNameStatic() { return "clang"; }
144
145 static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
146 Module *module, Target *target);
147
148 static LanguageSet GetSupportedLanguagesForTypes();
149 static LanguageSet GetSupportedLanguagesForExpressions();
150
151 static void Initialize();
152
153 static void Terminate();
154
155 static TypeSystemClang *GetASTContext(clang::ASTContext *ast_ctx);
156
157 /// Returns the display name of this TypeSystemClang that indicates what
158 /// purpose it serves in LLDB. Used for example in logs.
159 llvm::StringRef getDisplayName() const { return m_display_name; }
160
161 /// Returns the clang::ASTContext instance managed by this TypeSystemClang.
162 clang::ASTContext &getASTContext();
163
164 clang::MangleContext *getMangleContext();
165
166 std::shared_ptr<clang::TargetOptions> &getTargetOptions();
167
168 clang::TargetInfo *getTargetInfo();
169
170 void setSema(clang::Sema *s);
171 clang::Sema *getSema() { return m_sema; }
172
173 const char *GetTargetTriple();
174
175 void SetExternalSource(
176 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> &ast_source_up);
177
178 bool GetCompleteDecl(clang::Decl *decl) {
179 return TypeSystemClang::GetCompleteDecl(ast: &getASTContext(), decl);
180 }
181
182 static void DumpDeclHiearchy(clang::Decl *decl);
183
184 static void DumpDeclContextHiearchy(clang::DeclContext *decl_ctx);
185
186 static bool GetCompleteDecl(clang::ASTContext *ast, clang::Decl *decl);
187
188 void SetMetadataAsUserID(const clang::Decl *decl, lldb::user_id_t user_id);
189 void SetMetadataAsUserID(const clang::Type *type, lldb::user_id_t user_id);
190
191 void SetMetadata(const clang::Decl *object, ClangASTMetadata &meta_data);
192
193 void SetMetadata(const clang::Type *object, ClangASTMetadata &meta_data);
194 ClangASTMetadata *GetMetadata(const clang::Decl *object);
195 ClangASTMetadata *GetMetadata(const clang::Type *object);
196
197 void SetCXXRecordDeclAccess(const clang::CXXRecordDecl *object,
198 clang::AccessSpecifier access);
199 clang::AccessSpecifier
200 GetCXXRecordDeclAccess(const clang::CXXRecordDecl *object);
201
202 // Basic Types
203 CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
204 size_t bit_size) override;
205
206 CompilerType GetBasicType(lldb::BasicType type);
207
208 static lldb::BasicType GetBasicTypeEnumeration(llvm::StringRef name);
209
210 CompilerType
211 GetBuiltinTypeForDWARFEncodingAndBitSize(llvm::StringRef type_name,
212 uint32_t dw_ate, uint32_t bit_size);
213
214 CompilerType GetCStringType(bool is_const);
215
216 static clang::DeclContext *GetDeclContextForType(clang::QualType type);
217
218 static clang::DeclContext *GetDeclContextForType(const CompilerType &type);
219
220 CompilerDeclContext
221 GetCompilerDeclContextForType(const CompilerType &type) override;
222
223 uint32_t GetPointerByteSize() override;
224
225 clang::TranslationUnitDecl *GetTranslationUnitDecl() {
226 return getASTContext().getTranslationUnitDecl();
227 }
228
229 static bool AreTypesSame(CompilerType type1, CompilerType type2,
230 bool ignore_qualifiers = false);
231
232 /// Creates a CompilerType from the given QualType with the current
233 /// TypeSystemClang instance as the CompilerType's typesystem.
234 /// \param qt The QualType for a type that belongs to the ASTContext of this
235 /// TypeSystemClang.
236 /// \return The CompilerType representing the given QualType. If the
237 /// QualType's type pointer is a nullptr then the function returns an
238 /// invalid CompilerType.
239 CompilerType GetType(clang::QualType qt) {
240 if (qt.getTypePtrOrNull() == nullptr)
241 return CompilerType();
242 // Check that the type actually belongs to this TypeSystemClang.
243 assert(qt->getAsTagDecl() == nullptr ||
244 &qt->getAsTagDecl()->getASTContext() == &getASTContext());
245 return CompilerType(weak_from_this(), qt.getAsOpaquePtr());
246 }
247
248 CompilerType GetTypeForDecl(clang::NamedDecl *decl);
249
250 CompilerType GetTypeForDecl(clang::TagDecl *decl);
251
252 CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
253
254 template <typename RecordDeclType>
255 CompilerType
256 GetTypeForIdentifier(llvm::StringRef type_name,
257 clang::DeclContext *decl_context = nullptr) {
258 CompilerType compiler_type;
259 if (type_name.empty())
260 return compiler_type;
261
262 clang::ASTContext &ast = getASTContext();
263 if (!decl_context)
264 decl_context = ast.getTranslationUnitDecl();
265
266 clang::IdentifierInfo &myIdent = ast.Idents.get(Name: type_name);
267 clang::DeclarationName myName =
268 ast.DeclarationNames.getIdentifier(ID: &myIdent);
269 clang::DeclContext::lookup_result result = decl_context->lookup(Name: myName);
270 if (result.empty())
271 return compiler_type;
272
273 clang::NamedDecl *named_decl = *result.begin();
274 if (const RecordDeclType *record_decl =
275 llvm::dyn_cast<RecordDeclType>(named_decl))
276 compiler_type = CompilerType(
277 weak_from_this(),
278 clang::QualType(record_decl->getTypeForDecl(), 0).getAsOpaquePtr());
279
280 return compiler_type;
281 }
282
283 CompilerType CreateStructForIdentifier(
284 llvm::StringRef type_name,
285 const std::initializer_list<std::pair<const char *, CompilerType>>
286 &type_fields,
287 bool packed = false);
288
289 CompilerType GetOrCreateStructForIdentifier(
290 llvm::StringRef type_name,
291 const std::initializer_list<std::pair<const char *, CompilerType>>
292 &type_fields,
293 bool packed = false);
294
295 static bool IsOperator(llvm::StringRef name,
296 clang::OverloadedOperatorKind &op_kind);
297
298 // Structure, Unions, Classes
299
300 static clang::AccessSpecifier
301 ConvertAccessTypeToAccessSpecifier(lldb::AccessType access);
302
303 static clang::AccessSpecifier
304 UnifyAccessSpecifiers(clang::AccessSpecifier lhs, clang::AccessSpecifier rhs);
305
306 uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl,
307 bool omit_empty_base_classes);
308
309 uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl,
310 clang::NamedDecl *canonical_decl,
311 bool omit_empty_base_classes);
312
313 uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl,
314 const clang::CXXBaseSpecifier *base_spec,
315 bool omit_empty_base_classes);
316
317 /// Synthesize a clang::Module and return its ID or a default-constructed ID.
318 OptionalClangModuleID GetOrCreateClangModule(llvm::StringRef name,
319 OptionalClangModuleID parent,
320 bool is_framework = false,
321 bool is_explicit = false);
322
323 CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
324 OptionalClangModuleID owning_module,
325 lldb::AccessType access_type,
326 llvm::StringRef name, int kind,
327 lldb::LanguageType language,
328 ClangASTMetadata *metadata = nullptr,
329 bool exports_symbols = false);
330
331 class TemplateParameterInfos {
332 public:
333 TemplateParameterInfos() = default;
334 TemplateParameterInfos(llvm::ArrayRef<const char *> names_in,
335 llvm::ArrayRef<clang::TemplateArgument> args_in)
336 : names(names_in), args(args_in) {
337 assert(names.size() == args_in.size());
338 }
339
340 TemplateParameterInfos(TemplateParameterInfos const &) = delete;
341 TemplateParameterInfos(TemplateParameterInfos &&) = delete;
342
343 TemplateParameterInfos &operator=(TemplateParameterInfos const &) = delete;
344 TemplateParameterInfos &operator=(TemplateParameterInfos &&) = delete;
345
346 ~TemplateParameterInfos() = default;
347
348 bool IsValid() const {
349 // Having a pack name but no packed args doesn't make sense, so mark
350 // these template parameters as invalid.
351 if (pack_name && !packed_args)
352 return false;
353 return args.size() == names.size() &&
354 (!packed_args || !packed_args->packed_args);
355 }
356
357 bool IsEmpty() const { return args.empty(); }
358 size_t Size() const { return args.size(); }
359
360 llvm::ArrayRef<clang::TemplateArgument> GetArgs() const { return args; }
361 llvm::ArrayRef<const char *> GetNames() const { return names; }
362
363 clang::TemplateArgument const &Front() const {
364 assert(!args.empty());
365 return args.front();
366 }
367
368 void InsertArg(char const *name, clang::TemplateArgument arg) {
369 args.emplace_back(Args: std::move(arg));
370 names.push_back(Elt: name);
371 }
372
373 // Parameter pack related
374
375 bool hasParameterPack() const { return static_cast<bool>(packed_args); }
376
377 TemplateParameterInfos const &GetParameterPack() const {
378 assert(packed_args != nullptr);
379 return *packed_args;
380 }
381
382 TemplateParameterInfos &GetParameterPack() {
383 assert(packed_args != nullptr);
384 return *packed_args;
385 }
386
387 llvm::ArrayRef<clang::TemplateArgument> GetParameterPackArgs() const {
388 assert(packed_args != nullptr);
389 return packed_args->GetArgs();
390 }
391
392 bool HasPackName() const { return pack_name && pack_name[0]; }
393
394 llvm::StringRef GetPackName() const {
395 assert(HasPackName());
396 return pack_name;
397 }
398
399 void SetPackName(char const *name) { pack_name = name; }
400
401 void SetParameterPack(std::unique_ptr<TemplateParameterInfos> args) {
402 packed_args = std::move(args);
403 }
404
405 private:
406 /// Element 'names[i]' holds the template argument name
407 /// of 'args[i]'
408 llvm::SmallVector<const char *, 2> names;
409 llvm::SmallVector<clang::TemplateArgument, 2> args;
410
411 const char * pack_name = nullptr;
412 std::unique_ptr<TemplateParameterInfos> packed_args;
413 };
414
415 clang::FunctionTemplateDecl *CreateFunctionTemplateDecl(
416 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
417 clang::FunctionDecl *func_decl, const TemplateParameterInfos &infos);
418
419 void CreateFunctionTemplateSpecializationInfo(
420 clang::FunctionDecl *func_decl, clang::FunctionTemplateDecl *Template,
421 const TemplateParameterInfos &infos);
422
423 clang::ClassTemplateDecl *CreateClassTemplateDecl(
424 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
425 lldb::AccessType access_type, llvm::StringRef class_name, int kind,
426 const TemplateParameterInfos &infos);
427
428 clang::TemplateTemplateParmDecl *
429 CreateTemplateTemplateParmDecl(const char *template_name);
430
431 clang::ClassTemplateSpecializationDecl *CreateClassTemplateSpecializationDecl(
432 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
433 clang::ClassTemplateDecl *class_template_decl, int kind,
434 const TemplateParameterInfos &infos);
435
436 CompilerType
437 CreateClassTemplateSpecializationType(clang::ClassTemplateSpecializationDecl *
438 class_template_specialization_decl);
439
440 static clang::DeclContext *
441 GetAsDeclContext(clang::FunctionDecl *function_decl);
442
443 static bool CheckOverloadedOperatorKindParameterCount(
444 bool is_method, clang::OverloadedOperatorKind op_kind,
445 uint32_t num_params);
446
447 bool FieldIsBitfield(clang::FieldDecl *field, uint32_t &bitfield_bit_size);
448
449 bool RecordHasFields(const clang::RecordDecl *record_decl);
450
451 bool BaseSpecifierIsEmpty(const clang::CXXBaseSpecifier *b);
452
453 CompilerType CreateObjCClass(llvm::StringRef name,
454 clang::DeclContext *decl_ctx,
455 OptionalClangModuleID owning_module,
456 bool isForwardDecl, bool isInternal,
457 ClangASTMetadata *metadata = nullptr);
458
459 // Returns a mask containing bits from the TypeSystemClang::eTypeXXX
460 // enumerations
461
462 // Namespace Declarations
463
464 clang::NamespaceDecl *
465 GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx,
466 OptionalClangModuleID owning_module,
467 bool is_inline = false);
468
469 // Function Types
470
471 clang::FunctionDecl *CreateFunctionDeclaration(
472 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
473 llvm::StringRef name, const CompilerType &function_Type,
474 clang::StorageClass storage, bool is_inline);
475
476 CompilerType
477 CreateFunctionType(const CompilerType &result_type, const CompilerType *args,
478 unsigned num_args, bool is_variadic, unsigned type_quals,
479 clang::CallingConv cc = clang::CC_C,
480 clang::RefQualifierKind ref_qual = clang::RQ_None);
481
482 clang::ParmVarDecl *
483 CreateParameterDeclaration(clang::DeclContext *decl_ctx,
484 OptionalClangModuleID owning_module,
485 const char *name, const CompilerType &param_type,
486 int storage, bool add_decl = false);
487
488 void SetFunctionParameters(clang::FunctionDecl *function_decl,
489 llvm::ArrayRef<clang::ParmVarDecl *> params);
490
491 CompilerType CreateBlockPointerType(const CompilerType &function_type);
492
493 // Array Types
494
495 CompilerType CreateArrayType(const CompilerType &element_type,
496 size_t element_count, bool is_vector);
497
498 // Enumeration Types
499 CompilerType CreateEnumerationType(llvm::StringRef name,
500 clang::DeclContext *decl_ctx,
501 OptionalClangModuleID owning_module,
502 const Declaration &decl,
503 const CompilerType &integer_qual_type,
504 bool is_scoped);
505
506 // Integer type functions
507
508 CompilerType GetIntTypeFromBitSize(size_t bit_size, bool is_signed);
509
510 CompilerType GetPointerSizedIntType(bool is_signed);
511
512 // Floating point functions
513
514 static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
515 size_t bit_size);
516
517 // TypeSystem methods
518 plugin::dwarf::DWARFASTParser *GetDWARFParser() override;
519 PDBASTParser *GetPDBParser() override;
520 npdb::PdbAstBuilder *GetNativePDBParser() override;
521
522 // TypeSystemClang callbacks for external source lookups.
523 void CompleteTagDecl(clang::TagDecl *);
524
525 void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *);
526
527 bool LayoutRecordType(
528 const clang::RecordDecl *record_decl, uint64_t &size, uint64_t &alignment,
529 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
530 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
531 &base_offsets,
532 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
533 &vbase_offsets);
534
535 /// Creates a CompilerDecl from the given Decl with the current
536 /// TypeSystemClang instance as its typesystem.
537 /// The Decl has to come from the ASTContext of this
538 /// TypeSystemClang.
539 CompilerDecl GetCompilerDecl(clang::Decl *decl) {
540 assert(&decl->getASTContext() == &getASTContext() &&
541 "CreateCompilerDecl for Decl from wrong ASTContext?");
542 return CompilerDecl(this, decl);
543 }
544
545 // CompilerDecl override functions
546 ConstString DeclGetName(void *opaque_decl) override;
547
548 ConstString DeclGetMangledName(void *opaque_decl) override;
549
550 CompilerDeclContext DeclGetDeclContext(void *opaque_decl) override;
551
552 CompilerType DeclGetFunctionReturnType(void *opaque_decl) override;
553
554 size_t DeclGetFunctionNumArguments(void *opaque_decl) override;
555
556 CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
557 size_t arg_idx) override;
558
559 std::vector<lldb_private::CompilerContext>
560 DeclGetCompilerContext(void *opaque_decl) override;
561
562 CompilerType GetTypeForDecl(void *opaque_decl) override;
563
564 // CompilerDeclContext override functions
565
566 /// Creates a CompilerDeclContext from the given DeclContext
567 /// with the current TypeSystemClang instance as its typesystem.
568 /// The DeclContext has to come from the ASTContext of this
569 /// TypeSystemClang.
570 CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx);
571
572 /// Set the owning module for \p decl.
573 static void SetOwningModule(clang::Decl *decl,
574 OptionalClangModuleID owning_module);
575
576 std::vector<CompilerDecl>
577 DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
578 const bool ignore_using_decls) override;
579
580 ConstString DeclContextGetName(void *opaque_decl_ctx) override;
581
582 ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override;
583
584 bool DeclContextIsClassMethod(void *opaque_decl_ctx) override;
585
586 bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
587 void *other_opaque_decl_ctx) override;
588
589 lldb::LanguageType DeclContextGetLanguage(void *opaque_decl_ctx) override;
590
591 std::vector<lldb_private::CompilerContext>
592 DeclContextGetCompilerContext(void *opaque_decl_ctx) override;
593
594 // Clang specific clang::DeclContext functions
595
596 static clang::DeclContext *
597 DeclContextGetAsDeclContext(const CompilerDeclContext &dc);
598
599 static clang::ObjCMethodDecl *
600 DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc);
601
602 static clang::CXXMethodDecl *
603 DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc);
604
605 static clang::FunctionDecl *
606 DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc);
607
608 static clang::NamespaceDecl *
609 DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc);
610
611 static ClangASTMetadata *DeclContextGetMetaData(const CompilerDeclContext &dc,
612 const clang::Decl *object);
613
614 static clang::ASTContext *
615 DeclContextGetTypeSystemClang(const CompilerDeclContext &dc);
616
617 // Tests
618
619#ifndef NDEBUG
620 bool Verify(lldb::opaque_compiler_type_t type) override;
621#endif
622
623 bool IsArrayType(lldb::opaque_compiler_type_t type,
624 CompilerType *element_type, uint64_t *size,
625 bool *is_incomplete) override;
626
627 bool IsVectorType(lldb::opaque_compiler_type_t type,
628 CompilerType *element_type, uint64_t *size) override;
629
630 bool IsAggregateType(lldb::opaque_compiler_type_t type) override;
631
632 bool IsAnonymousType(lldb::opaque_compiler_type_t type) override;
633
634 bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;
635
636 bool IsCharType(lldb::opaque_compiler_type_t type) override;
637
638 bool IsCompleteType(lldb::opaque_compiler_type_t type) override;
639
640 bool IsConst(lldb::opaque_compiler_type_t type) override;
641
642 bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length);
643
644 static bool IsCXXClassType(const CompilerType &type);
645
646 bool IsDefined(lldb::opaque_compiler_type_t type) override;
647
648 bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
649 bool &is_complex) override;
650
651 bool IsFunctionType(lldb::opaque_compiler_type_t type) override;
652
653 uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
654 CompilerType *base_type_ptr) override;
655
656 size_t
657 GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override;
658
659 CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
660 const size_t index) override;
661
662 bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override;
663
664 bool IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type) override;
665
666 bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
667 CompilerType *function_pointer_type_ptr) override;
668
669 bool IsIntegerType(lldb::opaque_compiler_type_t type,
670 bool &is_signed) override;
671
672 bool IsEnumerationType(lldb::opaque_compiler_type_t type,
673 bool &is_signed) override;
674
675 bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) override;
676
677 static bool IsObjCClassType(const CompilerType &type);
678
679 static bool IsObjCClassTypeAndHasIVars(const CompilerType &type,
680 bool check_superclass);
681
682 static bool IsObjCObjectOrInterfaceType(const CompilerType &type);
683
684 static bool IsObjCObjectPointerType(const CompilerType &type,
685 CompilerType *target_type = nullptr);
686
687 bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override;
688
689 static bool IsClassType(lldb::opaque_compiler_type_t type);
690
691 static bool IsEnumType(lldb::opaque_compiler_type_t type);
692
693 bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
694 CompilerType *target_type, // Can pass nullptr
695 bool check_cplusplus, bool check_objc) override;
696
697 bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override;
698
699 bool IsPointerType(lldb::opaque_compiler_type_t type,
700 CompilerType *pointee_type) override;
701
702 bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
703 CompilerType *pointee_type) override;
704
705 bool IsReferenceType(lldb::opaque_compiler_type_t type,
706 CompilerType *pointee_type, bool *is_rvalue) override;
707
708 bool IsScalarType(lldb::opaque_compiler_type_t type) override;
709
710 bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
711
712 bool IsVoidType(lldb::opaque_compiler_type_t type) override;
713
714 bool CanPassInRegisters(const CompilerType &type) override;
715
716 bool SupportsLanguage(lldb::LanguageType language) override;
717
718 static std::optional<std::string> GetCXXClassName(const CompilerType &type);
719
720 // Type Completion
721
722 bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
723
724 bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) override;
725
726 // Accessors
727
728 ConstString GetTypeName(lldb::opaque_compiler_type_t type,
729 bool base_only) override;
730
731 ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) override;
732
733 uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type,
734 CompilerType *pointee_or_element_compiler_type) override;
735
736 lldb::LanguageType
737 GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
738
739 lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
740
741 unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
742
743 // Creating related types
744
745 CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type,
746 ExecutionContextScope *exe_scope) override;
747
748 CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
749 uint64_t size) override;
750
751 CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
752
753 CompilerType
754 GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;
755
756 CompilerType
757 GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) override;
758
759 // Returns -1 if this isn't a function of if the function doesn't have a
760 // prototype Returns a value >= 0 if there is a prototype.
761 int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
762
763 CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
764 size_t idx) override;
765
766 CompilerType
767 GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;
768
769 size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override;
770
771 TypeMemberFunctionImpl
772 GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
773 size_t idx) override;
774
775 CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;
776
777 CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;
778
779 CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
780
781 CompilerType
782 GetLValueReferenceType(lldb::opaque_compiler_type_t type) override;
783
784 CompilerType
785 GetRValueReferenceType(lldb::opaque_compiler_type_t type) override;
786
787 CompilerType GetAtomicType(lldb::opaque_compiler_type_t type) override;
788
789 CompilerType AddConstModifier(lldb::opaque_compiler_type_t type) override;
790
791 CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type) override;
792
793 CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type) override;
794
795 /// Using the current type, create a new typedef to that type using
796 /// "typedef_name" as the name and "decl_ctx" as the decl context.
797 /// \param opaque_payload is an opaque TypePayloadClang.
798 CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
799 const char *name,
800 const CompilerDeclContext &decl_ctx,
801 uint32_t opaque_payload) override;
802
803 // If the current object represents a typedef type, get the underlying type
804 CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
805
806 // Create related types using the current type's AST
807 CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
808
809 // Create a generic function prototype that can be used in ValuObject types
810 // to correctly display a function pointer with the right value and summary.
811 CompilerType CreateGenericFunctionPrototype() override;
812
813 // Exploring the type
814
815 const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) override;
816
817 std::optional<uint64_t> GetByteSize(lldb::opaque_compiler_type_t type,
818 ExecutionContextScope *exe_scope) {
819 if (std::optional<uint64_t> bit_size = GetBitSize(type, exe_scope))
820 return (*bit_size + 7) / 8;
821 return std::nullopt;
822 }
823
824 std::optional<uint64_t> GetBitSize(lldb::opaque_compiler_type_t type,
825 ExecutionContextScope *exe_scope) override;
826
827 lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
828 uint64_t &count) override;
829
830 lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
831
832 std::optional<size_t>
833 GetTypeBitAlign(lldb::opaque_compiler_type_t type,
834 ExecutionContextScope *exe_scope) override;
835
836 llvm::Expected<uint32_t>
837 GetNumChildren(lldb::opaque_compiler_type_t type,
838 bool omit_empty_base_classes,
839 const ExecutionContext *exe_ctx) override;
840
841 CompilerType GetBuiltinTypeByName(ConstString name) override;
842
843 lldb::BasicType
844 GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
845
846 void ForEachEnumerator(
847 lldb::opaque_compiler_type_t type,
848 std::function<bool(const CompilerType &integer_type,
849 ConstString name,
850 const llvm::APSInt &value)> const &callback) override;
851
852 uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
853
854 CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
855 std::string &name, uint64_t *bit_offset_ptr,
856 uint32_t *bitfield_bit_size_ptr,
857 bool *is_bitfield_ptr) override;
858
859 uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override;
860
861 uint32_t GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override;
862
863 CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type,
864 size_t idx,
865 uint32_t *bit_offset_ptr) override;
866
867 CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type,
868 size_t idx,
869 uint32_t *bit_offset_ptr) override;
870
871 static uint32_t GetNumPointeeChildren(clang::QualType type);
872
873 CompilerType GetChildCompilerTypeAtIndex(
874 lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
875 bool transparent_pointers, bool omit_empty_base_classes,
876 bool ignore_array_bounds, std::string &child_name,
877 uint32_t &child_byte_size, int32_t &child_byte_offset,
878 uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
879 bool &child_is_base_class, bool &child_is_deref_of_parent,
880 ValueObject *valobj, uint64_t &language_flags) override;
881
882 // Lookup a child given a name. This function will match base class names and
883 // member member names in "clang_type" only, not descendants.
884 uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
885 llvm::StringRef name,
886 bool omit_empty_base_classes) override;
887
888 // Lookup a child member given a name. This function will match member names
889 // only and will descend into "clang_type" children in search for the first
890 // member in this class, or any base class that matches "name".
891 // TODO: Return all matches for a given name by returning a
892 // vector<vector<uint32_t>>
893 // so we catch all names that match a given child name, not just the first.
894 size_t
895 GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
896 llvm::StringRef name,
897 bool omit_empty_base_classes,
898 std::vector<uint32_t> &child_indexes) override;
899
900 CompilerType GetDirectNestedTypeWithName(lldb::opaque_compiler_type_t type,
901 llvm::StringRef name) override;
902
903 bool IsTemplateType(lldb::opaque_compiler_type_t type) override;
904
905 size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
906 bool expand_pack) override;
907
908 lldb::TemplateArgumentKind
909 GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx,
910 bool expand_pack) override;
911 CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
912 size_t idx, bool expand_pack) override;
913 std::optional<CompilerType::IntegralTemplateArgument>
914 GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
915 bool expand_pack) override;
916
917 CompilerType GetTypeForFormatters(void *type) override;
918
919#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
920 // LLDB_INVALID_DECL_LEVEL is returned by CountDeclLevels if child_decl_ctx
921 // could not be found in decl_ctx.
922 uint32_t CountDeclLevels(clang::DeclContext *frame_decl_ctx,
923 clang::DeclContext *child_decl_ctx,
924 ConstString *child_name = nullptr,
925 CompilerType *child_type = nullptr);
926
927 // Modifying RecordType
928 static clang::FieldDecl *AddFieldToRecordType(const CompilerType &type,
929 llvm::StringRef name,
930 const CompilerType &field_type,
931 lldb::AccessType access,
932 uint32_t bitfield_bit_size);
933
934 static void BuildIndirectFields(const CompilerType &type);
935
936 static void SetIsPacked(const CompilerType &type);
937
938 static clang::VarDecl *AddVariableToRecordType(const CompilerType &type,
939 llvm::StringRef name,
940 const CompilerType &var_type,
941 lldb::AccessType access);
942
943 /// Initializes a variable with an integer value.
944 /// \param var The variable to initialize. Must not already have an
945 /// initializer and must have an integer or enum type.
946 /// \param init_value The integer value that the variable should be
947 /// initialized to. Has to match the bit width of the
948 /// variable type.
949 static void SetIntegerInitializerForVariable(clang::VarDecl *var,
950 const llvm::APInt &init_value);
951
952 /// Initializes a variable with a floating point value.
953 /// \param var The variable to initialize. Must not already have an
954 /// initializer and must have a floating point type.
955 /// \param init_value The float value that the variable should be
956 /// initialized to.
957 static void
958 SetFloatingInitializerForVariable(clang::VarDecl *var,
959 const llvm::APFloat &init_value);
960
961 clang::CXXMethodDecl *AddMethodToCXXRecordType(
962 lldb::opaque_compiler_type_t type, llvm::StringRef name,
963 const char *mangled_name, const CompilerType &method_type,
964 lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
965 bool is_explicit, bool is_attr_used, bool is_artificial);
966
967 void AddMethodOverridesForCXXRecordType(lldb::opaque_compiler_type_t type);
968
969 // C++ Base Classes
970 std::unique_ptr<clang::CXXBaseSpecifier>
971 CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
972 lldb::AccessType access, bool is_virtual,
973 bool base_of_class);
974
975 bool TransferBaseClasses(
976 lldb::opaque_compiler_type_t type,
977 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases);
978
979 static bool SetObjCSuperClass(const CompilerType &type,
980 const CompilerType &superclass_compiler_type);
981
982 static bool AddObjCClassProperty(const CompilerType &type,
983 const char *property_name,
984 const CompilerType &property_compiler_type,
985 clang::ObjCIvarDecl *ivar_decl,
986 const char *property_setter_name,
987 const char *property_getter_name,
988 uint32_t property_attributes,
989 ClangASTMetadata *metadata);
990
991 static clang::ObjCMethodDecl *AddMethodToObjCObjectType(
992 const CompilerType &type,
993 const char *name, // the full symbol name as seen in the symbol table
994 // (lldb::opaque_compiler_type_t type, "-[NString
995 // stringWithCString:]")
996 const CompilerType &method_compiler_type, bool is_artificial,
997 bool is_variadic, bool is_objc_direct_call);
998
999 static bool SetHasExternalStorage(lldb::opaque_compiler_type_t type,
1000 bool has_extern);
1001
1002 // Tag Declarations
1003 static bool StartTagDeclarationDefinition(const CompilerType &type);
1004
1005 static bool CompleteTagDeclarationDefinition(const CompilerType &type);
1006
1007 // Modifying Enumeration types
1008 clang::EnumConstantDecl *AddEnumerationValueToEnumerationType(
1009 const CompilerType &enum_type, const Declaration &decl, const char *name,
1010 int64_t enum_value, uint32_t enum_value_bit_size);
1011 clang::EnumConstantDecl *AddEnumerationValueToEnumerationType(
1012 const CompilerType &enum_type, const Declaration &decl, const char *name,
1013 const llvm::APSInt &value);
1014
1015 /// Returns the underlying integer type for an enum type. If the given type
1016 /// is invalid or not an enum-type, the function returns an invalid
1017 /// CompilerType.
1018 CompilerType GetEnumerationIntegerType(CompilerType type);
1019
1020 // Pointers & References
1021
1022 // Call this function using the class type when you want to make a member
1023 // pointer type to pointee_type.
1024 static CompilerType CreateMemberPointerType(const CompilerType &type,
1025 const CompilerType &pointee_type);
1026
1027 // Dumping types
1028#ifndef NDEBUG
1029 /// Convenience LLVM-style dump method for use in the debugger only.
1030 /// In contrast to the other \p Dump() methods this directly invokes
1031 /// \p clang::QualType::dump().
1032 LLVM_DUMP_METHOD void dump(lldb::opaque_compiler_type_t type) const override;
1033#endif
1034
1035 /// \see lldb_private::TypeSystem::Dump
1036 void Dump(llvm::raw_ostream &output) override;
1037
1038 /// Dump clang AST types from the symbol file.
1039 ///
1040 /// \param[in] s
1041 /// A stream to send the dumped AST node(s) to
1042 /// \param[in] symbol_name
1043 /// The name of the symbol to dump, if it is empty dump all the symbols
1044 void DumpFromSymbolFile(Stream &s, llvm::StringRef symbol_name);
1045
1046 bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s,
1047 lldb::Format format, const DataExtractor &data,
1048 lldb::offset_t data_offset, size_t data_byte_size,
1049 uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
1050 ExecutionContextScope *exe_scope) override;
1051
1052 void DumpTypeDescription(
1053 lldb::opaque_compiler_type_t type,
1054 lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) override;
1055
1056 void DumpTypeDescription(
1057 lldb::opaque_compiler_type_t type, Stream &s,
1058 lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) override;
1059
1060 static void DumpTypeName(const CompilerType &type);
1061
1062 static clang::EnumDecl *GetAsEnumDecl(const CompilerType &type);
1063
1064 static clang::RecordDecl *GetAsRecordDecl(const CompilerType &type);
1065
1066 static clang::TagDecl *GetAsTagDecl(const CompilerType &type);
1067
1068 static clang::TypedefNameDecl *GetAsTypedefDecl(const CompilerType &type);
1069
1070 static clang::CXXRecordDecl *
1071 GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type);
1072
1073 static clang::ObjCInterfaceDecl *
1074 GetAsObjCInterfaceDecl(const CompilerType &type);
1075
1076 clang::ClassTemplateDecl *ParseClassTemplateDecl(
1077 clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
1078 lldb::AccessType access_type, const char *parent_name, int tag_decl_kind,
1079 const TypeSystemClang::TemplateParameterInfos &template_param_infos);
1080
1081 clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx,
1082 OptionalClangModuleID owning_module);
1083
1084 clang::UsingDirectiveDecl *
1085 CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
1086 OptionalClangModuleID owning_module,
1087 clang::NamespaceDecl *ns_decl);
1088
1089 clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
1090 OptionalClangModuleID owning_module,
1091 clang::NamedDecl *target);
1092
1093 clang::VarDecl *CreateVariableDeclaration(clang::DeclContext *decl_context,
1094 OptionalClangModuleID owning_module,
1095 const char *name,
1096 clang::QualType type);
1097
1098 static lldb::opaque_compiler_type_t
1099 GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType basic_type);
1100
1101 static clang::QualType GetQualType(lldb::opaque_compiler_type_t type) {
1102 if (type)
1103 return clang::QualType::getFromOpaquePtr(Ptr: type);
1104 return clang::QualType();
1105 }
1106
1107 static clang::QualType
1108 GetCanonicalQualType(lldb::opaque_compiler_type_t type) {
1109 if (type)
1110 return clang::QualType::getFromOpaquePtr(Ptr: type).getCanonicalType();
1111 return clang::QualType();
1112 }
1113
1114 clang::DeclarationName
1115 GetDeclarationName(llvm::StringRef name,
1116 const CompilerType &function_clang_type);
1117
1118 clang::LangOptions *GetLangOpts() const {
1119 return m_language_options_up.get();
1120 }
1121 clang::SourceManager *GetSourceMgr() const {
1122 return m_source_manager_up.get();
1123 }
1124
1125 /// Complete a type from debug info, or mark it as forcefully completed if
1126 /// there is no definition of the type in the current Module. Call this
1127 /// function in contexts where the usual C++ rules require a type to be
1128 /// complete (base class, member, etc.).
1129 static void RequireCompleteType(CompilerType type);
1130
1131 bool SetDeclIsForcefullyCompleted(const clang::TagDecl *td);
1132
1133 /// Return the template parameters (including surrounding <>) in string form.
1134 std::string
1135 PrintTemplateParams(const TemplateParameterInfos &template_param_infos);
1136
1137private:
1138 /// Returns the PrintingPolicy used when generating the internal type names.
1139 /// These type names are mostly used for the formatter selection.
1140 clang::PrintingPolicy GetTypePrintingPolicy();
1141 /// Returns the internal type name for the given NamedDecl using the
1142 /// type printing policy.
1143 std::string GetTypeNameForDecl(const clang::NamedDecl *named_decl,
1144 bool qualified = true);
1145
1146 const clang::ClassTemplateSpecializationDecl *
1147 GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
1148
1149 bool IsTypeImpl(lldb::opaque_compiler_type_t type,
1150 llvm::function_ref<bool(clang::QualType)> predicate) const;
1151
1152 // Classes that inherit from TypeSystemClang can see and modify these
1153 std::string m_target_triple;
1154 std::unique_ptr<clang::ASTContext> m_ast_up;
1155 std::unique_ptr<clang::LangOptions> m_language_options_up;
1156 std::unique_ptr<clang::FileManager> m_file_manager_up;
1157 std::unique_ptr<clang::SourceManager> m_source_manager_up;
1158 std::unique_ptr<clang::DiagnosticsEngine> m_diagnostics_engine_up;
1159 std::unique_ptr<clang::DiagnosticConsumer> m_diagnostic_consumer_up;
1160 std::shared_ptr<clang::TargetOptions> m_target_options_rp;
1161 std::unique_ptr<clang::TargetInfo> m_target_info_up;
1162 std::unique_ptr<clang::IdentifierTable> m_identifier_table_up;
1163 std::unique_ptr<clang::SelectorTable> m_selector_table_up;
1164 std::unique_ptr<clang::Builtin::Context> m_builtins_up;
1165 std::unique_ptr<clang::HeaderSearch> m_header_search_up;
1166 std::unique_ptr<clang::ModuleMap> m_module_map_up;
1167 std::unique_ptr<DWARFASTParserClang> m_dwarf_ast_parser_up;
1168 std::unique_ptr<PDBASTParser> m_pdb_ast_parser_up;
1169 std::unique_ptr<npdb::PdbAstBuilder> m_native_pdb_ast_parser_up;
1170 std::unique_ptr<clang::MangleContext> m_mangle_ctx_up;
1171 uint32_t m_pointer_byte_size = 0;
1172 bool m_ast_owned = false;
1173 /// A string describing what this TypeSystemClang represents (e.g.,
1174 /// AST for debug information, an expression, some other utility ClangAST).
1175 /// Useful for logging and debugging.
1176 std::string m_display_name;
1177
1178 typedef llvm::DenseMap<const clang::Decl *, ClangASTMetadata> DeclMetadataMap;
1179 /// Maps Decls to their associated ClangASTMetadata.
1180 DeclMetadataMap m_decl_metadata;
1181
1182 typedef llvm::DenseMap<const clang::Type *, ClangASTMetadata> TypeMetadataMap;
1183 /// Maps Types to their associated ClangASTMetadata.
1184 TypeMetadataMap m_type_metadata;
1185
1186 typedef llvm::DenseMap<const clang::CXXRecordDecl *, clang::AccessSpecifier>
1187 CXXRecordDeclAccessMap;
1188 /// Maps CXXRecordDecl to their most recent added method/field's
1189 /// AccessSpecifier.
1190 CXXRecordDeclAccessMap m_cxx_record_decl_access;
1191
1192 /// The sema associated that is currently used to build this ASTContext.
1193 /// May be null if we are already done parsing this ASTContext or the
1194 /// ASTContext wasn't created by parsing source code.
1195 clang::Sema *m_sema = nullptr;
1196
1197 // For TypeSystemClang only
1198 TypeSystemClang(const TypeSystemClang &);
1199 const TypeSystemClang &operator=(const TypeSystemClang &);
1200 /// Creates the internal ASTContext.
1201 void CreateASTContext();
1202 void SetTargetTriple(llvm::StringRef target_triple);
1203};
1204
1205/// The TypeSystemClang instance used for the scratch ASTContext in a
1206/// lldb::Target.
1207class ScratchTypeSystemClang : public TypeSystemClang {
1208 /// LLVM RTTI support
1209 static char ID;
1210
1211public:
1212 ScratchTypeSystemClang(Target &target, llvm::Triple triple);
1213
1214 ~ScratchTypeSystemClang() override = default;
1215
1216 void Finalize() override;
1217
1218 /// The different kinds of isolated ASTs within the scratch TypeSystem.
1219 ///
1220 /// These ASTs are isolated from the main scratch AST and are each
1221 /// dedicated to a special language option/feature that makes the contained
1222 /// AST nodes incompatible with other AST nodes.
1223 enum IsolatedASTKind {
1224 /// The isolated AST for declarations/types from expressions that imported
1225 /// type information from a C++ module. The templates from a C++ module
1226 /// often conflict with the templates we generate from debug information,
1227 /// so we put these types in their own AST.
1228 CppModules
1229 };
1230
1231 /// Alias for requesting the default scratch TypeSystemClang in GetForTarget.
1232 // This isn't constexpr as gtest/std::optional comparison logic is trying
1233 // to get the address of this for pretty-printing.
1234 static const std::nullopt_t DefaultAST;
1235
1236 /// Infers the appropriate sub-AST from Clang's LangOptions.
1237 static std::optional<IsolatedASTKind>
1238 InferIsolatedASTKindFromLangOpts(const clang::LangOptions &l) {
1239 // If modules are activated we want the dedicated C++ module AST.
1240 // See IsolatedASTKind::CppModules for more info.
1241 if (l.Modules)
1242 return IsolatedASTKind::CppModules;
1243 return DefaultAST;
1244 }
1245
1246 /// Returns the scratch TypeSystemClang for the given target.
1247 /// \param target The Target which scratch TypeSystemClang should be returned.
1248 /// \param ast_kind Allows requesting a specific sub-AST instead of the
1249 /// default scratch AST. See also `IsolatedASTKind`.
1250 /// \param create_on_demand If the scratch TypeSystemClang instance can be
1251 /// created by this call if it doesn't exist yet. If it doesn't exist yet and
1252 /// this parameter is false, this function returns a nullptr.
1253 /// \return The scratch type system of the target or a nullptr in case an
1254 /// error occurred.
1255 static lldb::TypeSystemClangSP
1256 GetForTarget(Target &target,
1257 std::optional<IsolatedASTKind> ast_kind = DefaultAST,
1258 bool create_on_demand = true);
1259
1260 /// Returns the scratch TypeSystemClang for the given target. The returned
1261 /// TypeSystemClang will be the scratch AST or a sub-AST, depending on which
1262 /// fits best to the passed LangOptions.
1263 /// \param target The Target which scratch TypeSystemClang should be returned.
1264 /// \param lang_opts The LangOptions of a clang ASTContext that the caller
1265 /// wants to export type information from. This is used to
1266 /// find the best matching sub-AST that will be returned.
1267 static lldb::TypeSystemClangSP
1268 GetForTarget(Target &target, const clang::LangOptions &lang_opts) {
1269 return GetForTarget(target, ast_kind: InferIsolatedASTKindFromLangOpts(l: lang_opts));
1270 }
1271
1272 /// \see lldb_private::TypeSystem::Dump
1273 void Dump(llvm::raw_ostream &output) override;
1274
1275 UserExpression *
1276 GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
1277 lldb::LanguageType language,
1278 Expression::ResultType desired_type,
1279 const EvaluateExpressionOptions &options,
1280 ValueObject *ctx_obj) override;
1281
1282 FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
1283 const Address &function_address,
1284 const ValueList &arg_value_list,
1285 const char *name) override;
1286
1287 std::unique_ptr<UtilityFunction>
1288 CreateUtilityFunction(std::string text, std::string name) override;
1289
1290 PersistentExpressionState *GetPersistentExpressionState() override;
1291
1292 /// Unregisters the given ASTContext as a source from the scratch AST (and
1293 /// all sub-ASTs).
1294 /// \see ClangASTImporter::ForgetSource
1295 void ForgetSource(clang::ASTContext *src_ctx, ClangASTImporter &importer);
1296
1297 // llvm casting support
1298 bool isA(const void *ClassID) const override {
1299 return ClassID == &ID || TypeSystemClang::isA(ClassID);
1300 }
1301 static bool classof(const TypeSystem *ts) { return ts->isA(ClassID: &ID); }
1302
1303private:
1304 std::unique_ptr<ClangASTSource> CreateASTSource();
1305 /// Returns the requested sub-AST.
1306 /// Will lazily create the sub-AST if it hasn't been created before.
1307 TypeSystemClang &GetIsolatedAST(IsolatedASTKind feature);
1308
1309 /// The target triple.
1310 /// This was potentially adjusted and might not be identical to the triple
1311 /// of `m_target_wp`.
1312 llvm::Triple m_triple;
1313 lldb::TargetWP m_target_wp;
1314 /// The persistent variables associated with this process for the expression
1315 /// parser.
1316 std::unique_ptr<ClangPersistentVariables> m_persistent_variables;
1317 /// The ExternalASTSource that performs lookups and completes minimally
1318 /// imported types.
1319 std::unique_ptr<ClangASTSource> m_scratch_ast_source_up;
1320
1321 // FIXME: GCC 5.x doesn't support enum as map keys.
1322 typedef int IsolatedASTKey;
1323
1324 /// Map from IsolatedASTKind to their actual TypeSystemClang instance.
1325 /// This map is lazily filled with sub-ASTs and should be accessed via
1326 /// `GetSubAST` (which lazily fills this map).
1327 llvm::DenseMap<IsolatedASTKey, std::shared_ptr<TypeSystemClang>>
1328 m_isolated_asts;
1329};
1330
1331} // namespace lldb_private
1332
1333#endif // LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_TYPESYSTEMCLANG_H
1334

source code of lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h