LLDB mainline
TypeSystem.h
Go to the documentation of this file.
1//===-- TypeSystem.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_SYMBOL_TYPESYSTEM_H
10#define LLDB_SYMBOL_TYPESYSTEM_H
11
12#include <functional>
13#include <mutex>
14#include <optional>
15#include <string>
16
17#include "llvm/ADT/APFloat.h"
18#include "llvm/ADT/APSInt.h"
19#include "llvm/ADT/DenseMap.h"
20#include "llvm/ADT/SmallBitVector.h"
21#include "llvm/Support/Casting.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Support/JSON.h"
24
29#include "lldb/Symbol/Type.h"
30#include "lldb/Utility/Scalar.h"
31#include "lldb/lldb-forward.h"
32#include "lldb/lldb-private.h"
33#include "lldb/lldb-types.h"
34
35class PDBASTParser;
36
37namespace lldb_private {
38
39namespace plugin {
40namespace dwarf {
41class DWARFDIE;
42class DWARFASTParser;
43} // namespace dwarf
44} // namespace plugin
45
46namespace npdb {
47 class PdbAstBuilder;
48} // namespace npdb
49
50/// Interface for representing a type system.
51///
52/// Implemented by language plugins to define the type system for a given
53/// language.
54///
55/// This interface extensively used opaque pointers to prevent that generic
56/// LLDB code has dependencies on language plugins. The type and semantics of
57/// these opaque pointers are defined by the TypeSystem implementation inside
58/// the respective language plugin. Opaque pointers from one TypeSystem
59/// instance should never be passed to a different TypeSystem instance (even
60/// when the language plugin for both TypeSystem instances is the same).
61///
62/// Most of the functions in this class should not be called directly but only
63/// called by their respective counterparts in CompilerType, CompilerDecl and
64/// CompilerDeclContext.
65///
66/// \see lldb_private::CompilerType
67/// \see lldb_private::CompilerDecl
68/// \see lldb_private::CompilerDeclContext
70 public std::enable_shared_from_this<TypeSystem> {
71public:
72 // Constructors and Destructors
74 ~TypeSystem() override;
75
76 // LLVM RTTI support
77 virtual bool isA(const void *ClassID) const = 0;
78
80 Module *module);
81
83 Target *target);
84
85 /// Free up any resources associated with this TypeSystem. Done before
86 /// removing all the TypeSystems from the TypeSystemMap.
87 virtual void Finalize() {}
88
89 virtual plugin::dwarf::DWARFASTParser *GetDWARFParser() { return nullptr; }
90
91 virtual PDBASTParser *GetPDBParser() { return nullptr; }
92 virtual npdb::PdbAstBuilder *GetNativePDBParser() { return nullptr; }
93
94 virtual SymbolFile *GetSymbolFile() const { return m_sym_file; }
95
96 virtual void SetSymbolFile(SymbolFile *sym_file) { m_sym_file = sym_file; }
97
98 // CompilerDecl functions
99 virtual ConstString DeclGetName(void *opaque_decl) = 0;
100
101 virtual ConstString DeclGetMangledName(void *opaque_decl);
102
103 virtual CompilerDeclContext DeclGetDeclContext(void *opaque_decl);
104
105 virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl);
106
107 virtual size_t DeclGetFunctionNumArguments(void *opaque_decl);
108
109 virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
110 size_t arg_idx);
111
112 virtual std::vector<lldb_private::CompilerContext>
113 DeclGetCompilerContext(void *opaque_decl);
114
115 virtual Scalar DeclGetConstantValue(void *opaque_decl) { return Scalar(); }
116
117 virtual CompilerType GetTypeForDecl(void *opaque_decl) = 0;
118
119 // CompilerDeclContext functions
120
121 virtual std::vector<CompilerDecl>
122 DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
123 const bool ignore_imported_decls);
124
125 virtual ConstString DeclContextGetName(void *opaque_decl_ctx) = 0;
126
127 virtual ConstString
128 DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) = 0;
129
130 virtual bool DeclContextIsClassMethod(void *opaque_decl_ctx) = 0;
131
132 virtual bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
133 void *other_opaque_decl_ctx) = 0;
134
135 virtual lldb::LanguageType DeclContextGetLanguage(void *opaque_decl_ctx) = 0;
136
137 /// Returns the direct parent context of specified type
138 virtual CompilerDeclContext
140
141 virtual std::vector<lldb_private::CompilerContext>
142 DeclContextGetCompilerContext(void *opaque_decl_ctx);
143
144 // Tests
145#ifndef NDEBUG
146 /// Verify the integrity of the type to catch CompilerTypes that mix
147 /// and match invalid TypeSystem/Opaque type pairs.
148 virtual bool Verify(lldb::opaque_compiler_type_t type) = 0;
149#endif
150
152 CompilerType *element_type, uint64_t *size,
153 bool *is_incomplete) = 0;
154
156
158
160
162
164
166 uint32_t &count, bool &is_complex) = 0;
167
169
170 virtual size_t
172
173 virtual CompilerType
175 const size_t index) = 0;
176
178
179 virtual bool
181
183 CompilerType *function_pointer_type_ptr) = 0;
184
186 bool &is_signed) = 0;
187
189 bool &is_signed) {
190 is_signed = false;
191 return false;
192 }
193
195
197 CompilerType *target_type, // Can pass NULL
198 bool check_cplusplus, bool check_objc) = 0;
199
201 CompilerType *pointee_type) = 0;
202
204
206
207 virtual bool CanPassInRegisters(const CompilerType &type) = 0;
208
209 // TypeSystems can support more than one language
210 virtual bool SupportsLanguage(lldb::LanguageType language) = 0;
211
212 static bool SupportsLanguageStatic(lldb::LanguageType language);
213 // Type Completion
214
216
218 return false;
219 }
220
221 // AST related queries
222
223 virtual uint32_t GetPointerByteSize() = 0;
224
225 virtual unsigned GetPtrAuthKey(lldb::opaque_compiler_type_t type) = 0;
226
227 virtual unsigned
229
230 virtual bool
232
233 // Accessors
234
236 bool BaseOnly) = 0;
237
239
240 virtual uint32_t
242 CompilerType *pointee_or_element_compiler_type) = 0;
243
244 virtual lldb::LanguageType
246
247 virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) = 0;
248
249 // Creating related types
250
251 virtual CompilerType
253 ExecutionContextScope *exe_scope) = 0;
254
256 uint64_t size);
257
259
260 virtual CompilerType
262
263 // Returns -1 if this isn't a function of if the function doesn't have a
264 // prototype Returns a value >= 0 if there is a prototype.
266
267 virtual CompilerType
269 size_t idx) = 0;
270
271 virtual CompilerType
273
275
278
280
282
283 virtual CompilerType
285
286 virtual CompilerType
288
290
292
294
296
298 uint32_t payload);
299
300 /// \param opaque_payload The m_payload field of Type, which may
301 /// carry TypeSystem-specific extra information.
303 const char *name,
304 const CompilerDeclContext &decl_ctx,
305 uint32_t opaque_payload);
306
307 // Exploring the type
308
309 virtual const llvm::fltSemantics &GetFloatTypeSemantics(size_t byte_size) = 0;
310
311 virtual std::optional<uint64_t>
313 ExecutionContextScope *exe_scope) = 0;
314
316 uint64_t &count) = 0;
317
319
320 virtual llvm::Expected<uint32_t>
322 bool omit_empty_base_classes,
323 const ExecutionContext *exe_ctx) = 0;
324
326
327 virtual lldb::BasicType
329
330 virtual void ForEachEnumerator(
332 std::function<bool(const CompilerType &integer_type,
333 ConstString name,
334 const llvm::APSInt &value)> const &callback) {}
335
336 virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0;
337
339 size_t idx, std::string &name,
340 uint64_t *bit_offset_ptr,
341 uint32_t *bitfield_bit_size_ptr,
342 bool *is_bitfield_ptr) = 0;
343
344 virtual uint32_t
346
347 virtual uint32_t
349
350 virtual CompilerType
352 uint32_t *bit_offset_ptr) = 0;
353
354 virtual CompilerType
356 uint32_t *bit_offset_ptr) = 0;
357
359 llvm::StringRef name) {
360 return CompilerDecl();
361 }
362
363 virtual llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(
364 lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
365 bool transparent_pointers, bool omit_empty_base_classes,
366 bool ignore_array_bounds, std::string &child_name,
367 uint32_t &child_byte_size, int32_t &child_byte_offset,
368 uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
369 bool &child_is_base_class, bool &child_is_deref_of_parent,
370 ValueObject *valobj, uint64_t &language_flags) = 0;
371
372 // Lookup a child given a name. This function will match base class names and
373 // member member names in "clang_type" only, not descendants.
375 llvm::StringRef name,
376 bool omit_empty_base_classes) = 0;
377
378 // Lookup a child member given a name. This function will match member names
379 // only and will descend into "clang_type" children in search for the first
380 // member in this class, or any base class that matches "name".
381 // TODO: Return all matches for a given name by returning a
382 // vector<vector<uint32_t>>
383 // so we catch all names that match a given child name, not just the first.
385 lldb::opaque_compiler_type_t type, llvm::StringRef name,
386 bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) = 0;
387
388 virtual CompilerType
390 llvm::StringRef name) {
391 return CompilerType();
392 }
393
395
397 bool expand_pack);
398
401 bool expand_pack);
402 virtual CompilerType
404 bool expand_pack);
405 virtual std::optional<CompilerType::IntegralTemplateArgument>
407 bool expand_pack);
408
409 // Dumping types
410
411#ifndef NDEBUG
412 /// Convenience LLVM-style dump method for use in the debugger only.
413 LLVM_DUMP_METHOD virtual void
415#endif
416
418 lldb::Format format, const DataExtractor &data,
419 lldb::offset_t data_offset, size_t data_byte_size,
420 uint32_t bitfield_bit_size,
421 uint32_t bitfield_bit_offset,
422 ExecutionContextScope *exe_scope) = 0;
423
424 /// Dump the type to stdout.
428
429 /// Print a description of the type to a stream. The exact implementation
430 /// varies, but the expectation is that eDescriptionLevelFull returns a
431 /// source-like representation of the type, whereas eDescriptionLevelVerbose
432 /// does a dump of the underlying AST if applicable.
436
437 /// Dump a textual representation of the internal TypeSystem state to the
438 /// given stream.
439 ///
440 /// This should not modify the state of the TypeSystem if possible.
441 virtual void Dump(llvm::raw_ostream &output) = 0;
442
443 /// This is used by swift.
445
446 // TODO: Determine if these methods should move to TypeSystemClang.
447
449 CompilerType *pointee_type) = 0;
450
452
453 virtual std::optional<size_t>
455 ExecutionContextScope *exe_scope) = 0;
456
458
460 return CompilerType();
461 }
462
463 virtual CompilerType
465 size_t bit_size) = 0;
466
468
469 virtual bool IsConst(lldb::opaque_compiler_type_t type) = 0;
470
472 CompilerType *base_type_ptr) = 0;
473
475
477
478 // If the current object represents a typedef type, get the underlying type
480
482 CompilerType *element_type, uint64_t *size) = 0;
483
484 virtual CompilerType
486
487 virtual CompilerType
489
491 CompilerType *pointee_type, bool *is_rvalue) = 0;
492
493 virtual bool
495 return IsPointerOrReferenceType(type, nullptr);
496 }
497
499 llvm::StringRef expr, llvm::StringRef prefix, SourceLanguage language,
500 Expression::ResultType desired_type,
501 const EvaluateExpressionOptions &options, ValueObject *ctx_obj) {
502 return nullptr;
503 }
504
505 virtual FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
506 const Address &function_address,
507 const ValueList &arg_value_list,
508 const char *name) {
509 return nullptr;
510 }
511
512 virtual std::unique_ptr<UtilityFunction>
513 CreateUtilityFunction(std::string text, std::string name);
514
516 return nullptr;
517 }
518
519 virtual CompilerType GetTypeForFormatters(void *type);
520
521 virtual LazyBool ShouldPrintAsOneLiner(void *type, ValueObject *valobj);
522
523 // Type systems can have types that are placeholder types, which are meant to
524 // indicate the presence of a type, but offer no actual information about
525 // said types, and leave the burden of actually figuring type information out
526 // to dynamic type resolution. For instance a language with a generics
527 // system, can use placeholder types to indicate "type argument goes here",
528 // without promising uniqueness of the placeholder, nor attaching any
529 // actually idenfiable information to said placeholder. This API allows type
530 // systems to tell LLDB when such a type has been encountered In response,
531 // the debugger can react by not using this type as a cache entry in any
532 // type-specific way For instance, LLDB will currently not cache any
533 // formatters that are discovered on such a type as attributable to the
534 // meaningless type itself, instead preferring to use the dynamic type
535 virtual bool IsMeaninglessWithoutDynamicResolution(void *type);
536
537 virtual std::optional<llvm::json::Value> ReportStatistics();
538
541 }
542protected:
544 /// Used for reporting statistics.
546};
547
549public:
552
553 // Clear calls Finalize on all the TypeSystems managed by this map, and then
554 // empties the map.
555 void Clear();
556
557 // Iterate through all of the type systems that are created. Return true from
558 // callback to keep iterating, false to stop iterating.
559 void ForEach(std::function<bool(lldb::TypeSystemSP)> const &callback);
560
561 llvm::Expected<lldb::TypeSystemSP>
563 bool can_create);
564
565 llvm::Expected<lldb::TypeSystemSP>
567 bool can_create);
568
569 /// Check all type systems in the map to see if any have forcefully completed
570 /// types;
572protected:
573 typedef llvm::DenseMap<uint16_t, lldb::TypeSystemSP> collection;
574 mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
575 /// multi-threaded environments.
578
579private:
580 typedef llvm::function_ref<lldb::TypeSystemSP()> CreateCallback;
581 /// Finds the type system for the given language. If no type system could be
582 /// found for a language and a CreateCallback was provided, the value
583 /// returned by the callback will be treated as the TypeSystem for the
584 /// language.
585 ///
586 /// \param language The language for which the type system should be found.
587 /// \param create_callback A callback that will be called if no previously
588 /// created TypeSystem that fits the given language
589 /// could found. Can be omitted if a non-existent
590 /// type system should be treated as an error
591 /// instead.
592 /// \return The found type system or an error.
593 llvm::Expected<lldb::TypeSystemSP> GetTypeSystemForLanguage(
594 lldb::LanguageType language,
595 std::optional<CreateCallback> create_callback = std::nullopt);
596 };
597
598 } // namespace lldb_private
599
600#endif // LLDB_SYMBOL_TYPESYSTEM_H
A section + offset based address class.
Definition: Address.h:62
Represents a generic declaration context in a program.
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
An data extractor class.
Definition: DataExtractor.h:48
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Encapsulates a function that can be called.
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:50
llvm::DenseMap< uint16_t, lldb::TypeSystemSP > collection
Definition: TypeSystem.h:573
std::mutex m_mutex
A mutex to keep this object happy in multi-threaded environments.
Definition: TypeSystem.h:574
bool GetHasForcefullyCompletedTypes() const
Check all type systems in the map to see if any have forcefully completed types;.
llvm::function_ref< lldb::TypeSystemSP()> CreateCallback
Definition: TypeSystem.h:580
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, bool can_create)
Definition: TypeSystem.cpp:316
void ForEach(std::function< bool(lldb::TypeSystemSP)> const &callback)
Definition: TypeSystem.cpp:238
Interface for representing a type system.
Definition: TypeSystem.h:70
virtual CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type)=0
virtual PersistentExpressionState * GetPersistentExpressionState()
Definition: TypeSystem.h:515
virtual CompilerType GetFunctionReturnType(lldb::opaque_compiler_type_t type)=0
virtual std::unique_ptr< UtilityFunction > CreateUtilityFunction(std::string text, std::string name)
Definition: TypeSystem.cpp:196
virtual void Finalize()
Free up any resources associated with this TypeSystem.
Definition: TypeSystem.h:87
virtual bool IsMeaninglessWithoutDynamicResolution(void *type)
Definition: TypeSystem.cpp:156
virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type, bool expand_pack)
Definition: TypeSystem.cpp:130
virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type, bool &is_signed)
Definition: TypeSystem.h:188
virtual bool GetPtrAuthAddressDiversity(lldb::opaque_compiler_type_t type)=0
virtual PDBASTParser * GetPDBParser()
Definition: TypeSystem.h:91
virtual CompilerType GetBuiltinTypeByName(ConstString name)
Definition: TypeSystem.cpp:118
virtual bool GetCompleteType(lldb::opaque_compiler_type_t type)=0
virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, bool expand_pack)
Definition: TypeSystem.cpp:141
virtual CompilerType GetTypeForFormatters(void *type)
Definition: TypeSystem.cpp:122
virtual unsigned GetPtrAuthDiscriminator(lldb::opaque_compiler_type_t type)=0
virtual bool IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size)=0
virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:107
virtual CompilerType GetAtomicType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:88
virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetLValueReferenceType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:79
virtual std::vector< CompilerDecl > DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name, const bool ignore_imported_decls)
Definition: TypeSystem.cpp:190
virtual void ForEachEnumerator(lldb::opaque_compiler_type_t type, std::function< bool(const CompilerType &integer_type, ConstString name, const llvm::APSInt &value)> const &callback)
Definition: TypeSystem.h:330
virtual unsigned GetPtrAuthKey(lldb::opaque_compiler_type_t type)=0
virtual uint32_t GetPointerByteSize()=0
virtual ConstString DeclGetName(void *opaque_decl)=0
virtual bool IsAggregateType(lldb::opaque_compiler_type_t type)=0
virtual bool IsDefined(lldb::opaque_compiler_type_t type)=0
virtual std::optional< size_t > GetTypeBitAlign(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)=0
virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type, bool BaseOnly)=0
virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, llvm::StringRef name, bool omit_empty_base_classes)=0
virtual bool DeclContextIsClassMethod(void *opaque_decl_ctx)=0
virtual std::optional< llvm::json::Value > ReportStatistics()
Definition: TypeSystem.cpp:200
virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx, uint32_t opaque_payload)
Definition: TypeSystem.cpp:111
virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream &s, lldb::DescriptionLevel level=lldb::eDescriptionLevelFull)=0
Print a description of the type to a stream.
virtual bool IsCompleteType(lldb::opaque_compiler_type_t type)=0
virtual Scalar DeclGetConstantValue(void *opaque_decl)
Definition: TypeSystem.h:115
virtual bool IsFunctionType(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index)=0
virtual const llvm::fltSemantics & GetFloatTypeSemantics(size_t byte_size)=0
virtual CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type)=0
virtual FunctionCaller * GetFunctionCaller(const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name)
Definition: TypeSystem.h:505
virtual std::optional< uint64_t > GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)=0
virtual LazyBool ShouldPrintAsOneLiner(void *type, ValueObject *valobj)
Definition: TypeSystem.cpp:152
virtual size_t GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, llvm::StringRef name, bool omit_empty_base_classes, std::vector< uint32_t > &child_indexes)=0
virtual bool IsTypedefType(lldb::opaque_compiler_type_t type)=0
virtual bool IsBlockPointerType(lldb::opaque_compiler_type_t type, CompilerType *function_pointer_type_ptr)=0
virtual bool IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed)=0
virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type)=0
virtual SymbolFile * GetSymbolFile() const
Definition: TypeSystem.h:94
virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:92
bool m_has_forcefully_completed_types
Used for reporting statistics.
Definition: TypeSystem.h:545
virtual npdb::PdbAstBuilder * GetNativePDBParser()
Definition: TypeSystem.h:92
SymbolFile * m_sym_file
Definition: TypeSystem.h:543
virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type)=0
virtual uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type)=0
virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)=0
virtual CompilerType AddPtrAuthModifier(lldb::opaque_compiler_type_t type, uint32_t payload)
Definition: TypeSystem.cpp:96
virtual uint32_t GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type)=0
virtual CompilerDecl GetStaticFieldWithName(lldb::opaque_compiler_type_t type, llvm::StringRef name)
Definition: TypeSystem.h:358
virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl)
Definition: TypeSystem.cpp:168
virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count)=0
virtual bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)=0
virtual CompilerType GetDirectNestedTypeWithName(lldb::opaque_compiler_type_t type, llvm::StringRef name)
Definition: TypeSystem.h:389
virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type)=0
virtual bool DeclContextIsContainedInLookup(void *opaque_decl_ctx, void *other_opaque_decl_ctx)=0
virtual LLVM_DUMP_METHOD void dump(lldb::opaque_compiler_type_t type) const =0
Convenience LLVM-style dump method for use in the debugger only.
virtual bool IsFunctionPointerType(lldb::opaque_compiler_type_t type)=0
virtual bool IsCharType(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetTypeForDecl(void *opaque_decl)=0
virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl, size_t arg_idx)
Definition: TypeSystem.cpp:174
virtual void SetSymbolFile(SymbolFile *sym_file)
Definition: TypeSystem.h:96
virtual bool IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetRValueReferenceType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:84
virtual std::vector< lldb_private::CompilerContext > DeclGetCompilerContext(void *opaque_decl)
Definition: TypeSystem.cpp:180
virtual bool IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue)=0
virtual UserExpression * GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix, SourceLanguage language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj)
Definition: TypeSystem.h:498
virtual std::vector< lldb_private::CompilerContext > DeclContextGetCompilerContext(void *opaque_decl_ctx)
Definition: TypeSystem.cpp:185
virtual lldb::LanguageType DeclContextGetLanguage(void *opaque_decl_ctx)=0
virtual bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type)=0
bool GetHasForcefullyCompletedTypes() const
Definition: TypeSystem.h:539
virtual bool IsAnonymousType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:69
virtual bool IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)=0
virtual ConstString DeclContextGetName(void *opaque_decl_ctx)=0
virtual ConstString DeclGetMangledName(void *opaque_decl)
Definition: TypeSystem.cpp:160
virtual bool IsVoidType(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type, uint64_t size)
Definition: TypeSystem.cpp:73
virtual bool IsConst(lldb::opaque_compiler_type_t type)=0
virtual llvm::Expected< CompilerType > GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name, uint32_t &child_byte_size, int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, bool &child_is_base_class, bool &child_is_deref_of_parent, ValueObject *valobj, uint64_t &language_flags)=0
virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type, lldb::DescriptionLevel level=lldb::eDescriptionLevelFull)=0
Dump the type to stdout.
static bool SupportsLanguageStatic(lldb::LanguageType language)
Definition: TypeSystem.cpp:339
virtual CompilerDeclContext GetCompilerDeclContextForType(const CompilerType &type)
Returns the direct parent context of specified type.
Definition: TypeSystem.cpp:205
virtual ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx)=0
virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr)=0
virtual CompilerType CreateGenericFunctionPrototype()
Definition: TypeSystem.h:459
virtual CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr)=0
virtual void Dump(llvm::raw_ostream &output)=0
Dump a textual representation of the internal TypeSystem state to the given stream.
virtual bool CanPassInRegisters(const CompilerType &type)=0
virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr)=0
virtual size_t GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type)=0
virtual bool SupportsLanguage(lldb::LanguageType language)=0
virtual CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)=0
virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type)=0
virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr)=0
virtual std::optional< CompilerType::IntegralTemplateArgument > GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, bool expand_pack)
Definition: TypeSystem.cpp:147
virtual bool Verify(lldb::opaque_compiler_type_t type)=0
Verify the integrity of the type to catch CompilerTypes that mix and match invalid TypeSystem/Opaque ...
Definition: TypeSystem.cpp:66
virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type)=0
virtual llvm::Expected< uint32_t > GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes, const ExecutionContext *exe_ctx)=0
virtual lldb::BasicType GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type)=0
virtual plugin::dwarf::DWARFASTParser * GetDWARFParser()
Definition: TypeSystem.h:89
virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type)=0
virtual ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type)=0
virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type)=0
virtual lldb::TemplateArgumentKind GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx, bool expand_pack)
Definition: TypeSystem.cpp:136
virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type)=0
This is used by swift.
virtual CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size)=0
virtual bool ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.h:494
virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope)=0
static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, Module *module)
Definition: TypeSystem.cpp:55
virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type)=0
virtual bool IsTemplateType(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:126
virtual bool isA(const void *ClassID) const =0
virtual size_t DeclGetFunctionNumArguments(void *opaque_decl)
Definition: TypeSystem.cpp:172
virtual bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.h:217
virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type)=0
virtual bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type, CompilerType *target_type, bool check_cplusplus, bool check_objc)=0
virtual CompilerDeclContext DeclGetDeclContext(void *opaque_decl)
Definition: TypeSystem.cpp:164
virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type)=0
virtual uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type)=0
virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type)
Definition: TypeSystem.cpp:102
virtual bool IsScalarType(lldb::opaque_compiler_type_t type)=0
virtual CompilerType GetEnumerationIntegerType(lldb::opaque_compiler_type_t type)=0
virtual bool IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete)=0
virtual TypeMemberFunctionImpl GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx)=0
virtual CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx)=0
Encapsulates a one-time expression for use in lldb.
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
Definition: lldb-forward.h:463
void * opaque_compiler_type_t
Definition: lldb-types.h:89
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelFull
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
Format
Display format definitions.
uint64_t offset_t
Definition: lldb-types.h:85
LanguageType
Programming language type.
Encoding
Register encoding definitions.
A type-erased pair of llvm::dwarf::SourceLanguageName and version.