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