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

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