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/Utility/Scalar.h" 31 #include "lldb/lldb-forward.h" 32 #include "lldb/lldb-private.h" 33 #include "lldb/lldb-types.h" 34 35 class PDBASTParser; 36 37 namespace lldb_private { 38 39 namespace plugin { 40 namespace dwarf { 41 class DWARFDIE; 42 class DWARFASTParser; 43 } // namespace dwarf 44 } // namespace plugin 45 46 namespace 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 69 class TypeSystem : public PluginInterface, 70 public std::enable_shared_from_this<TypeSystem> { 71 public: 72 // Constructors and Destructors 73 TypeSystem(); 74 ~TypeSystem() override; 75 76 // LLVM RTTI support 77 virtual bool isA(const void *ClassID) const = 0; 78 79 static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, 80 Module *module); 81 82 static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, 83 Target *target); 84 85 /// Free up any resources associated with this TypeSystem. Done before 86 /// removing all the TypeSystems from the TypeSystemMap. Finalize()87 virtual void Finalize() {} 88 GetDWARFParser()89 virtual plugin::dwarf::DWARFASTParser *GetDWARFParser() { return nullptr; } 90 GetPDBParser()91 virtual PDBASTParser *GetPDBParser() { return nullptr; } GetNativePDBParser()92 virtual npdb::PdbAstBuilder *GetNativePDBParser() { return nullptr; } 93 GetSymbolFile()94 virtual SymbolFile *GetSymbolFile() const { return m_sym_file; } 95 SetSymbolFile(SymbolFile * sym_file)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 DeclGetConstantValue(void * opaque_decl)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 139 GetCompilerDeclContextForType(const CompilerType &type); 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 151 virtual bool IsArrayType(lldb::opaque_compiler_type_t type, 152 CompilerType *element_type, uint64_t *size, 153 bool *is_incomplete) = 0; 154 155 virtual bool IsAggregateType(lldb::opaque_compiler_type_t type) = 0; 156 157 virtual bool IsAnonymousType(lldb::opaque_compiler_type_t type); 158 159 virtual bool IsCharType(lldb::opaque_compiler_type_t type) = 0; 160 161 virtual bool IsCompleteType(lldb::opaque_compiler_type_t type) = 0; 162 163 virtual bool IsDefined(lldb::opaque_compiler_type_t type) = 0; 164 165 virtual bool IsFloatingPointType(lldb::opaque_compiler_type_t type, 166 uint32_t &count, bool &is_complex) = 0; 167 168 virtual bool IsFunctionType(lldb::opaque_compiler_type_t type) = 0; 169 170 virtual size_t 171 GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) = 0; 172 173 virtual CompilerType 174 GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, 175 const size_t index) = 0; 176 177 virtual bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) = 0; 178 179 virtual bool 180 IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type) = 0; 181 182 virtual bool IsBlockPointerType(lldb::opaque_compiler_type_t type, 183 CompilerType *function_pointer_type_ptr) = 0; 184 185 virtual bool IsIntegerType(lldb::opaque_compiler_type_t type, 186 bool &is_signed) = 0; 187 IsEnumerationType(lldb::opaque_compiler_type_t type,bool & is_signed)188 virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type, 189 bool &is_signed) { 190 is_signed = false; 191 return false; 192 } 193 194 virtual bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) = 0; 195 196 virtual bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type, 197 CompilerType *target_type, // Can pass NULL 198 bool check_cplusplus, bool check_objc) = 0; 199 200 virtual bool IsPointerType(lldb::opaque_compiler_type_t type, 201 CompilerType *pointee_type) = 0; 202 203 virtual bool IsScalarType(lldb::opaque_compiler_type_t type) = 0; 204 205 virtual bool IsVoidType(lldb::opaque_compiler_type_t type) = 0; 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 215 virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) = 0; 216 IsForcefullyCompleted(lldb::opaque_compiler_type_t type)217 virtual bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) { 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 228 GetPtrAuthDiscriminator(lldb::opaque_compiler_type_t type) = 0; 229 230 virtual bool 231 GetPtrAuthAddressDiversity(lldb::opaque_compiler_type_t type) = 0; 232 233 // Accessors 234 235 virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type, 236 bool BaseOnly) = 0; 237 238 virtual ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) = 0; 239 240 virtual uint32_t 241 GetTypeInfo(lldb::opaque_compiler_type_t type, 242 CompilerType *pointee_or_element_compiler_type) = 0; 243 244 virtual lldb::LanguageType 245 GetMinimumLanguage(lldb::opaque_compiler_type_t type) = 0; 246 247 virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) = 0; 248 249 // Creating related types 250 251 virtual CompilerType 252 GetArrayElementType(lldb::opaque_compiler_type_t type, 253 ExecutionContextScope *exe_scope) = 0; 254 255 virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type, 256 uint64_t size); 257 258 virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) = 0; 259 260 virtual CompilerType 261 GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) = 0; 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. 265 virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) = 0; 266 267 virtual CompilerType 268 GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, 269 size_t idx) = 0; 270 271 virtual CompilerType 272 GetFunctionReturnType(lldb::opaque_compiler_type_t type) = 0; 273 274 virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) = 0; 275 276 virtual TypeMemberFunctionImpl 277 GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) = 0; 278 279 virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) = 0; 280 281 virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) = 0; 282 283 virtual CompilerType 284 GetLValueReferenceType(lldb::opaque_compiler_type_t type); 285 286 virtual CompilerType 287 GetRValueReferenceType(lldb::opaque_compiler_type_t type); 288 289 virtual CompilerType GetAtomicType(lldb::opaque_compiler_type_t type); 290 291 virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type); 292 293 virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type); 294 295 virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type); 296 297 virtual CompilerType AddPtrAuthModifier(lldb::opaque_compiler_type_t type, 298 uint32_t payload); 299 300 /// \param opaque_payload The m_payload field of Type, which may 301 /// carry TypeSystem-specific extra information. 302 virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type, 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> 312 GetBitSize(lldb::opaque_compiler_type_t type, 313 ExecutionContextScope *exe_scope) = 0; 314 315 virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, 316 uint64_t &count) = 0; 317 318 virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0; 319 320 virtual llvm::Expected<uint32_t> 321 GetNumChildren(lldb::opaque_compiler_type_t type, 322 bool omit_empty_base_classes, 323 const ExecutionContext *exe_ctx) = 0; 324 325 virtual CompilerType GetBuiltinTypeByName(ConstString name); 326 327 virtual lldb::BasicType 328 GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0; 329 ForEachEnumerator(lldb::opaque_compiler_type_t type,std::function<bool (const CompilerType & integer_type,ConstString name,const llvm::APSInt & value)> const & callback)330 virtual void ForEachEnumerator( 331 lldb::opaque_compiler_type_t type, 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 338 virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, 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 345 GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) = 0; 346 347 virtual uint32_t 348 GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) = 0; 349 350 virtual CompilerType 351 GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, 352 uint32_t *bit_offset_ptr) = 0; 353 354 virtual CompilerType 355 GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, 356 uint32_t *bit_offset_ptr) = 0; 357 GetStaticFieldWithName(lldb::opaque_compiler_type_t type,llvm::StringRef name)358 virtual CompilerDecl GetStaticFieldWithName(lldb::opaque_compiler_type_t type, 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. 374 virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, 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. 384 virtual size_t GetIndexOfChildMemberWithName( 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 GetDirectNestedTypeWithName(lldb::opaque_compiler_type_t type,llvm::StringRef name)389 GetDirectNestedTypeWithName(lldb::opaque_compiler_type_t type, 390 llvm::StringRef name) { 391 return CompilerType(); 392 } 393 394 virtual bool IsTemplateType(lldb::opaque_compiler_type_t type); 395 396 virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type, 397 bool expand_pack); 398 399 virtual lldb::TemplateArgumentKind 400 GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx, 401 bool expand_pack); 402 virtual CompilerType 403 GetTypeTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, 404 bool expand_pack); 405 virtual std::optional<CompilerType::IntegralTemplateArgument> 406 GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, 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 414 dump(lldb::opaque_compiler_type_t type) const = 0; 415 #endif 416 417 virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s, 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. 425 virtual void DumpTypeDescription( 426 lldb::opaque_compiler_type_t type, 427 lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0; 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. 433 virtual void DumpTypeDescription( 434 lldb::opaque_compiler_type_t type, Stream &s, 435 lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0; 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. 444 virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) = 0; 445 446 // TODO: Determine if these methods should move to TypeSystemClang. 447 448 virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, 449 CompilerType *pointee_type) = 0; 450 451 virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) = 0; 452 453 virtual std::optional<size_t> 454 GetTypeBitAlign(lldb::opaque_compiler_type_t type, 455 ExecutionContextScope *exe_scope) = 0; 456 457 virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) = 0; 458 CreateGenericFunctionPrototype()459 virtual CompilerType CreateGenericFunctionPrototype() { 460 return CompilerType(); 461 } 462 463 virtual CompilerType 464 GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, 465 size_t bit_size) = 0; 466 467 virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type) = 0; 468 469 virtual bool IsConst(lldb::opaque_compiler_type_t type) = 0; 470 471 virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, 472 CompilerType *base_type_ptr) = 0; 473 474 virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) = 0; 475 476 virtual bool IsTypedefType(lldb::opaque_compiler_type_t type) = 0; 477 478 // If the current object represents a typedef type, get the underlying type 479 virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) = 0; 480 481 virtual bool IsVectorType(lldb::opaque_compiler_type_t type, 482 CompilerType *element_type, uint64_t *size) = 0; 483 484 virtual CompilerType 485 GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) = 0; 486 487 virtual CompilerType 488 GetNonReferenceType(lldb::opaque_compiler_type_t type) = 0; 489 490 virtual bool IsReferenceType(lldb::opaque_compiler_type_t type, 491 CompilerType *pointee_type, bool *is_rvalue) = 0; 492 493 virtual bool ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type)494 ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type) { 495 return IsPointerOrReferenceType(type, nullptr); 496 } 497 GetUserExpression(llvm::StringRef expr,llvm::StringRef prefix,SourceLanguage language,Expression::ResultType desired_type,const EvaluateExpressionOptions & options,ValueObject * ctx_obj)498 virtual UserExpression *GetUserExpression( 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 GetFunctionCaller(const CompilerType & return_type,const Address & function_address,const ValueList & arg_value_list,const char * name)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 GetPersistentExpressionState()515 virtual PersistentExpressionState *GetPersistentExpressionState() { 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 GetHasForcefullyCompletedTypes()539 bool GetHasForcefullyCompletedTypes() const { 540 return m_has_forcefully_completed_types; 541 } 542 protected: 543 SymbolFile *m_sym_file = nullptr; 544 /// Used for reporting statistics. 545 bool m_has_forcefully_completed_types = false; 546 }; 547 548 class TypeSystemMap { 549 public: 550 TypeSystemMap(); 551 ~TypeSystemMap(); 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> 562 GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, 563 bool can_create); 564 565 llvm::Expected<lldb::TypeSystemSP> 566 GetTypeSystemForLanguage(lldb::LanguageType language, Target *target, 567 bool can_create); 568 569 /// Check all type systems in the map to see if any have forcefully completed 570 /// types; 571 bool GetHasForcefullyCompletedTypes() const; 572 protected: 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. 576 collection m_map; 577 bool m_clear_in_progress = false; 578 579 private: 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 601