1//===-- CPlusPlusLanguage.cpp -----------------------------------*- 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#include "CPlusPlusLanguage.h" 10 11#include <cctype> 12#include <cstring> 13 14#include <functional> 15#include <memory> 16#include <mutex> 17#include <set> 18 19#include "llvm/ADT/StringRef.h" 20#include "llvm/Demangle/ItaniumDemangle.h" 21 22#include "lldb/Core/Mangled.h" 23#include "lldb/Core/PluginManager.h" 24#include "lldb/Core/UniqueCStringMap.h" 25#include "lldb/DataFormatters/CXXFunctionPointer.h" 26#include "lldb/DataFormatters/DataVisualization.h" 27#include "lldb/DataFormatters/FormattersHelpers.h" 28#include "lldb/DataFormatters/VectorType.h" 29#include "lldb/Utility/ConstString.h" 30#include "lldb/Utility/Log.h" 31#include "lldb/Utility/RegularExpression.h" 32 33#include "BlockPointer.h" 34#include "CPlusPlusNameParser.h" 35#include "CxxStringTypes.h" 36#include "LibCxx.h" 37#include "LibCxxAtomic.h" 38#include "LibCxxVariant.h" 39#include "LibStdcpp.h" 40#include "MSVCUndecoratedNameParser.h" 41 42using namespace lldb; 43using namespace lldb_private; 44using namespace lldb_private::formatters; 45 46void CPlusPlusLanguage::Initialize() { 47 PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language", 48 CreateInstance); 49} 50 51void CPlusPlusLanguage::Terminate() { 52 PluginManager::UnregisterPlugin(CreateInstance); 53} 54 55lldb_private::ConstString CPlusPlusLanguage::GetPluginNameStatic() { 56 static ConstString g_name("cplusplus"); 57 return g_name; 58} 59 60// PluginInterface protocol 61 62lldb_private::ConstString CPlusPlusLanguage::GetPluginName() { 63 return GetPluginNameStatic(); 64} 65 66uint32_t CPlusPlusLanguage::GetPluginVersion() { return 1; } 67 68// Static Functions 69 70Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) { 71 if (Language::LanguageIsCPlusPlus(language)) 72 return new CPlusPlusLanguage(); 73 return nullptr; 74} 75 76void CPlusPlusLanguage::MethodName::Clear() { 77 m_full.Clear(); 78 m_basename = llvm::StringRef(); 79 m_context = llvm::StringRef(); 80 m_arguments = llvm::StringRef(); 81 m_qualifiers = llvm::StringRef(); 82 m_parsed = false; 83 m_parse_error = false; 84} 85 86static bool ReverseFindMatchingChars(const llvm::StringRef &s, 87 const llvm::StringRef &left_right_chars, 88 size_t &left_pos, size_t &right_pos, 89 size_t pos = llvm::StringRef::npos) { 90 assert(left_right_chars.size() == 2); 91 left_pos = llvm::StringRef::npos; 92 const char left_char = left_right_chars[0]; 93 const char right_char = left_right_chars[1]; 94 pos = s.find_last_of(left_right_chars, pos); 95 if (pos == llvm::StringRef::npos || s[pos] == left_char) 96 return false; 97 right_pos = pos; 98 uint32_t depth = 1; 99 while (pos > 0 && depth > 0) { 100 pos = s.find_last_of(left_right_chars, pos); 101 if (pos == llvm::StringRef::npos) 102 return false; 103 if (s[pos] == left_char) { 104 if (--depth == 0) { 105 left_pos = pos; 106 return left_pos < right_pos; 107 } 108 } else if (s[pos] == right_char) { 109 ++depth; 110 } 111 } 112 return false; 113} 114 115static bool IsTrivialBasename(const llvm::StringRef &basename) { 116 // Check that the basename matches with the following regular expression 117 // "^~?([A-Za-z_][A-Za-z_0-9]*)$" We are using a hand written implementation 118 // because it is significantly more efficient then using the general purpose 119 // regular expression library. 120 size_t idx = 0; 121 if (basename.size() > 0 && basename[0] == '~') 122 idx = 1; 123 124 if (basename.size() <= idx) 125 return false; // Empty string or "~" 126 127 if (!std::isalpha(basename[idx]) && basename[idx] != '_') 128 return false; // First charater (after removing the possible '~'') isn't in 129 // [A-Za-z_] 130 131 // Read all characters matching [A-Za-z_0-9] 132 ++idx; 133 while (idx < basename.size()) { 134 if (!std::isalnum(basename[idx]) && basename[idx] != '_') 135 break; 136 ++idx; 137 } 138 139 // We processed all characters. It is a vaild basename. 140 return idx == basename.size(); 141} 142 143bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() { 144 // This method tries to parse simple method definitions which are presumably 145 // most comman in user programs. Definitions that can be parsed by this 146 // function don't have return types and templates in the name. 147 // A::B::C::fun(std::vector<T> &) const 148 size_t arg_start, arg_end; 149 llvm::StringRef full(m_full.GetCString()); 150 llvm::StringRef parens("()", 2); 151 if (ReverseFindMatchingChars(full, parens, arg_start, arg_end)) { 152 m_arguments = full.substr(arg_start, arg_end - arg_start + 1); 153 if (arg_end + 1 < full.size()) 154 m_qualifiers = full.substr(arg_end + 1).ltrim(); 155 156 if (arg_start == 0) 157 return false; 158 size_t basename_end = arg_start; 159 size_t context_start = 0; 160 size_t context_end = full.rfind(':', basename_end); 161 if (context_end == llvm::StringRef::npos) 162 m_basename = full.substr(0, basename_end); 163 else { 164 if (context_start < context_end) 165 m_context = full.substr(context_start, context_end - 1 - context_start); 166 const size_t basename_begin = context_end + 1; 167 m_basename = full.substr(basename_begin, basename_end - basename_begin); 168 } 169 170 if (IsTrivialBasename(m_basename)) { 171 return true; 172 } else { 173 // The C++ basename doesn't match our regular expressions so this can't 174 // be a valid C++ method, clear everything out and indicate an error 175 m_context = llvm::StringRef(); 176 m_basename = llvm::StringRef(); 177 m_arguments = llvm::StringRef(); 178 m_qualifiers = llvm::StringRef(); 179 return false; 180 } 181 } 182 return false; 183} 184 185void CPlusPlusLanguage::MethodName::Parse() { 186 if (!m_parsed && m_full) { 187 if (TrySimplifiedParse()) { 188 m_parse_error = false; 189 } else { 190 CPlusPlusNameParser parser(m_full.GetStringRef()); 191 if (auto function = parser.ParseAsFunctionDefinition()) { 192 m_basename = function.getValue().name.basename; 193 m_context = function.getValue().name.context; 194 m_arguments = function.getValue().arguments; 195 m_qualifiers = function.getValue().qualifiers; 196 m_parse_error = false; 197 } else { 198 m_parse_error = true; 199 } 200 } 201 m_parsed = true; 202 } 203} 204 205llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() { 206 if (!m_parsed) 207 Parse(); 208 return m_basename; 209} 210 211llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() { 212 if (!m_parsed) 213 Parse(); 214 return m_context; 215} 216 217llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() { 218 if (!m_parsed) 219 Parse(); 220 return m_arguments; 221} 222 223llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() { 224 if (!m_parsed) 225 Parse(); 226 return m_qualifiers; 227} 228 229std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() { 230 if (!m_parsed) 231 Parse(); 232 if (m_context.empty()) 233 return m_basename; 234 235 std::string res; 236 res += m_context; 237 res += "::"; 238 res += m_basename; 239 return res; 240} 241 242bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) { 243 // FIXME!! we should really run through all the known C++ Language plugins 244 // and ask each one if this is a C++ mangled name 245 246 Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name); 247 248 if (scheme == Mangled::eManglingSchemeNone) 249 return false; 250 251 return true; 252} 253 254bool CPlusPlusLanguage::ExtractContextAndIdentifier( 255 const char *name, llvm::StringRef &context, llvm::StringRef &identifier) { 256 if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name)) 257 return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context, 258 identifier); 259 260 CPlusPlusNameParser parser(name); 261 if (auto full_name = parser.ParseAsFullName()) { 262 identifier = full_name.getValue().basename; 263 context = full_name.getValue().context; 264 return true; 265 } 266 return false; 267} 268 269namespace { 270class NodeAllocator { 271 llvm::BumpPtrAllocator Alloc; 272 273public: 274 void reset() { Alloc.Reset(); } 275 276 template <typename T, typename... Args> T *makeNode(Args &&... args) { 277 return new (Alloc.Allocate(sizeof(T), alignof(T))) 278 T(std::forward<Args>(args)...); 279 } 280 281 void *allocateNodeArray(size_t sz) { 282 return Alloc.Allocate(sizeof(llvm::itanium_demangle::Node *) * sz, 283 alignof(llvm::itanium_demangle::Node *)); 284 } 285}; 286 287template <typename Derived> 288class ManglingSubstitutor 289 : public llvm::itanium_demangle::AbstractManglingParser<Derived, 290 NodeAllocator> { 291 using Base = 292 llvm::itanium_demangle::AbstractManglingParser<Derived, NodeAllocator>; 293 294public: 295 ManglingSubstitutor() : Base(nullptr, nullptr) {} 296 297 template<typename... Ts> 298 ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) { 299 this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...); 300 return substituteImpl(Mangled); 301 } 302 303 304protected: 305 void reset(llvm::StringRef Mangled) { 306 Base::reset(Mangled.begin(), Mangled.end()); 307 Written = Mangled.begin(); 308 Result.clear(); 309 Substituted = false; 310 } 311 312 ConstString substituteImpl(llvm::StringRef Mangled) { 313 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); 314 if (this->parse() == nullptr) { 315 LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled); 316 return ConstString(); 317 } 318 if (!Substituted) 319 return ConstString(); 320 321 // Append any trailing unmodified input. 322 appendUnchangedInput(); 323 LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result); 324 return ConstString(Result); 325 } 326 327 void trySubstitute(llvm::StringRef From, llvm::StringRef To) { 328 if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From)) 329 return; 330 331 // We found a match. Append unmodified input up to this point. 332 appendUnchangedInput(); 333 334 // And then perform the replacement. 335 Result += To; 336 Written += From.size(); 337 Substituted = true; 338 } 339 340private: 341 /// Input character until which we have constructed the respective output 342 /// already. 343 const char *Written; 344 345 llvm::SmallString<128> Result; 346 347 /// Whether we have performed any substitutions. 348 bool Substituted; 349 350 const char *currentParserPos() const { return this->First; } 351 352 void appendUnchangedInput() { 353 Result += 354 llvm::StringRef(Written, std::distance(Written, currentParserPos())); 355 Written = currentParserPos(); 356 } 357 358}; 359 360/// Given a mangled function `Mangled`, replace all the primitive function type 361/// arguments of `Search` with type `Replace`. 362class TypeSubstitutor : public ManglingSubstitutor<TypeSubstitutor> { 363 llvm::StringRef Search; 364 llvm::StringRef Replace; 365 366public: 367 void reset(llvm::StringRef Mangled, llvm::StringRef Search, 368 llvm::StringRef Replace) { 369 ManglingSubstitutor::reset(Mangled); 370 this->Search = Search; 371 this->Replace = Replace; 372 } 373 374 llvm::itanium_demangle::Node *parseType() { 375 trySubstitute(Search, Replace); 376 return ManglingSubstitutor::parseType(); 377 } 378}; 379 380class CtorDtorSubstitutor : public ManglingSubstitutor<CtorDtorSubstitutor> { 381public: 382 llvm::itanium_demangle::Node * 383 parseCtorDtorName(llvm::itanium_demangle::Node *&SoFar, NameState *State) { 384 trySubstitute("C1", "C2"); 385 trySubstitute("D1", "D2"); 386 return ManglingSubstitutor::parseCtorDtorName(SoFar, State); 387 } 388}; 389} // namespace 390 391uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( 392 const ConstString mangled_name, std::set<ConstString> &alternates) { 393 const auto start_size = alternates.size(); 394 /// Get a basic set of alternative manglings for the given symbol `name`, by 395 /// making a few basic possible substitutions on basic types, storage duration 396 /// and `const`ness for the given symbol. The output parameter `alternates` 397 /// is filled with a best-guess, non-exhaustive set of different manglings 398 /// for the given name. 399 400 // Maybe we're looking for a const symbol but the debug info told us it was 401 // non-const... 402 if (!strncmp(mangled_name.GetCString(), "_ZN", 3) && 403 strncmp(mangled_name.GetCString(), "_ZNK", 4)) { 404 std::string fixed_scratch("_ZNK"); 405 fixed_scratch.append(mangled_name.GetCString() + 3); 406 alternates.insert(ConstString(fixed_scratch)); 407 } 408 409 // Maybe we're looking for a static symbol but we thought it was global... 410 if (!strncmp(mangled_name.GetCString(), "_Z", 2) && 411 strncmp(mangled_name.GetCString(), "_ZL", 3)) { 412 std::string fixed_scratch("_ZL"); 413 fixed_scratch.append(mangled_name.GetCString() + 2); 414 alternates.insert(ConstString(fixed_scratch)); 415 } 416 417 TypeSubstitutor TS; 418 // `char` is implementation defined as either `signed` or `unsigned`. As a 419 // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed 420 // char, 'h'-unsigned char. If we're looking for symbols with a signed char 421 // parameter, try finding matches which have the general case 'c'. 422 if (ConstString char_fixup = 423 TS.substitute(mangled_name.GetStringRef(), "a", "c")) 424 alternates.insert(char_fixup); 425 426 // long long parameter mangling 'x', may actually just be a long 'l' argument 427 if (ConstString long_fixup = 428 TS.substitute(mangled_name.GetStringRef(), "x", "l")) 429 alternates.insert(long_fixup); 430 431 // unsigned long long parameter mangling 'y', may actually just be unsigned 432 // long 'm' argument 433 if (ConstString ulong_fixup = 434 TS.substitute(mangled_name.GetStringRef(), "y", "m")) 435 alternates.insert(ulong_fixup); 436 437 if (ConstString ctor_fixup = 438 CtorDtorSubstitutor().substitute(mangled_name.GetStringRef())) 439 alternates.insert(ctor_fixup); 440 441 return alternates.size() - start_size; 442} 443 444static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { 445 if (!cpp_category_sp) 446 return; 447 448 TypeSummaryImpl::Flags stl_summary_flags; 449 stl_summary_flags.SetCascades(true) 450 .SetSkipPointers(false) 451 .SetSkipReferences(false) 452 .SetDontShowChildren(true) 453 .SetDontShowValue(true) 454 .SetShowMembersOneLiner(false) 455 .SetHideItemNames(false); 456 457 AddCXXSummary(cpp_category_sp, 458 lldb_private::formatters::LibcxxStringSummaryProviderASCII, 459 "std::string summary provider", 460 ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags, 461 true); 462 AddCXXSummary(cpp_category_sp, 463 lldb_private::formatters::LibcxxStringSummaryProviderASCII, 464 "std::string summary provider", 465 ConstString("^std::__[[:alnum:]]+::basic_string<char, " 466 "std::__[[:alnum:]]+::char_traits<char>, " 467 "std::__[[:alnum:]]+::allocator<char> >$"), 468 stl_summary_flags, true); 469 AddCXXSummary(cpp_category_sp, 470 lldb_private::formatters::LibcxxStringSummaryProviderASCII, 471 "std::string summary provider", 472 ConstString("^std::__[[:alnum:]]+::basic_string<unsigned char, " 473 "std::__[[:alnum:]]+::char_traits<unsigned char>, " 474 "std::__[[:alnum:]]+::allocator<unsigned char> >$"), 475 stl_summary_flags, true); 476 477 AddCXXSummary(cpp_category_sp, 478 lldb_private::formatters::LibcxxStringSummaryProviderUTF16, 479 "std::u16string summary provider", 480 ConstString( 481 "^std::__[[:alnum:]]+::basic_string<char16_t, " 482 "std::__[[:alnum:]]+::char_traits<char16_t>, " 483 "std::__[[:alnum:]]+::allocator<char16_t> >$"), 484 stl_summary_flags, true); 485 486 AddCXXSummary(cpp_category_sp, 487 lldb_private::formatters::LibcxxStringSummaryProviderUTF32, 488 "std::u32string summary provider", 489 ConstString( 490 "^std::__[[:alnum:]]+::basic_string<char32_t, " 491 "std::__[[:alnum:]]+::char_traits<char32_t>, " 492 "std::__[[:alnum:]]+::allocator<char32_t> >$"), 493 stl_summary_flags, true); 494 495 AddCXXSummary(cpp_category_sp, 496 lldb_private::formatters::LibcxxWStringSummaryProvider, 497 "std::wstring summary provider", 498 ConstString("^std::__[[:alnum:]]+::wstring$"), 499 stl_summary_flags, true); 500 AddCXXSummary(cpp_category_sp, 501 lldb_private::formatters::LibcxxWStringSummaryProvider, 502 "std::wstring summary provider", 503 ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, " 504 "std::__[[:alnum:]]+::char_traits<wchar_t>, " 505 "std::__[[:alnum:]]+::allocator<wchar_t> >$"), 506 stl_summary_flags, true); 507 508 SyntheticChildren::Flags stl_synth_flags; 509 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( 510 false); 511 SyntheticChildren::Flags stl_deref_flags = stl_synth_flags; 512 stl_deref_flags.SetFrontEndWantsDereference(); 513 514 AddCXXSynthetic( 515 cpp_category_sp, 516 lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator, 517 "libc++ std::bitset synthetic children", 518 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags, 519 true); 520 AddCXXSynthetic( 521 cpp_category_sp, 522 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, 523 "libc++ std::vector synthetic children", 524 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags, 525 true); 526 AddCXXSynthetic( 527 cpp_category_sp, 528 lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator, 529 "libc++ std::forward_list synthetic children", 530 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"), 531 stl_synth_flags, true); 532 AddCXXSynthetic( 533 cpp_category_sp, 534 lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, 535 "libc++ std::list synthetic children", 536 // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$" 537 // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$" 538 ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|" 539 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"), 540 stl_deref_flags, true); 541 AddCXXSynthetic( 542 cpp_category_sp, 543 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 544 "libc++ std::map synthetic children", 545 ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags, 546 true); 547 AddCXXSynthetic( 548 cpp_category_sp, 549 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 550 "libc++ std::set synthetic children", 551 ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags, 552 true); 553 AddCXXSynthetic( 554 cpp_category_sp, 555 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 556 "libc++ std::multiset synthetic children", 557 ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"), 558 stl_deref_flags, true); 559 AddCXXSynthetic( 560 cpp_category_sp, 561 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 562 "libc++ std::multimap synthetic children", 563 ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"), 564 stl_synth_flags, true); 565 AddCXXSynthetic( 566 cpp_category_sp, 567 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, 568 "libc++ std::unordered containers synthetic children", 569 ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"), 570 stl_synth_flags, true); 571 AddCXXSynthetic( 572 cpp_category_sp, 573 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, 574 "libc++ std::initializer_list synthetic children", 575 ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags, 576 true); 577 AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator, 578 "libc++ std::queue synthetic children", 579 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"), 580 stl_synth_flags, true); 581 AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator, 582 "libc++ std::tuple synthetic children", 583 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"), 584 stl_synth_flags, true); 585 AddCXXSynthetic(cpp_category_sp, LibcxxOptionalFrontEndCreator, 586 "libc++ std::optional synthetic children", 587 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"), 588 stl_synth_flags, true); 589 AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator, 590 "libc++ std::variant synthetic children", 591 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"), 592 stl_synth_flags, true); 593 AddCXXSynthetic( 594 cpp_category_sp, 595 lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator, 596 "libc++ std::atomic synthetic children", 597 ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true); 598 599 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 600 RegularExpression( 601 llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$")), 602 SyntheticChildrenSP(new ScriptedSyntheticChildren( 603 stl_synth_flags, 604 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider"))); 605 606 AddCXXSynthetic( 607 cpp_category_sp, 608 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, 609 "shared_ptr synthetic children", 610 ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"), 611 stl_synth_flags, true); 612 AddCXXSynthetic( 613 cpp_category_sp, 614 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, 615 "weak_ptr synthetic children", 616 ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"), 617 stl_synth_flags, true); 618 AddCXXSummary(cpp_category_sp, 619 lldb_private::formatters::LibcxxFunctionSummaryProvider, 620 "libc++ std::function summary provider", 621 ConstString("^std::__[[:alnum:]]+::function<.+>$"), 622 stl_summary_flags, true); 623 624 stl_summary_flags.SetDontShowChildren(false); 625 stl_summary_flags.SetSkipPointers(false); 626 AddCXXSummary(cpp_category_sp, 627 lldb_private::formatters::LibcxxContainerSummaryProvider, 628 "libc++ std::bitset summary provider", 629 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), 630 stl_summary_flags, true); 631 AddCXXSummary(cpp_category_sp, 632 lldb_private::formatters::LibcxxContainerSummaryProvider, 633 "libc++ std::vector summary provider", 634 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), 635 stl_summary_flags, true); 636 AddCXXSummary(cpp_category_sp, 637 lldb_private::formatters::LibcxxContainerSummaryProvider, 638 "libc++ std::list summary provider", 639 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"), 640 stl_summary_flags, true); 641 AddCXXSummary( 642 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, 643 "libc++ std::list summary provider", 644 // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$" 645 // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$" 646 ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|" 647 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"), 648 stl_summary_flags, true); 649 AddCXXSummary(cpp_category_sp, 650 lldb_private::formatters::LibcxxContainerSummaryProvider, 651 "libc++ std::map summary provider", 652 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"), 653 stl_summary_flags, true); 654 AddCXXSummary(cpp_category_sp, 655 lldb_private::formatters::LibcxxContainerSummaryProvider, 656 "libc++ std::deque summary provider", 657 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"), 658 stl_summary_flags, true); 659 AddCXXSummary(cpp_category_sp, 660 lldb_private::formatters::LibcxxContainerSummaryProvider, 661 "libc++ std::queue summary provider", 662 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"), 663 stl_summary_flags, true); 664 AddCXXSummary(cpp_category_sp, 665 lldb_private::formatters::LibcxxContainerSummaryProvider, 666 "libc++ std::set summary provider", 667 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"), 668 stl_summary_flags, true); 669 AddCXXSummary(cpp_category_sp, 670 lldb_private::formatters::LibcxxContainerSummaryProvider, 671 "libc++ std::multiset summary provider", 672 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"), 673 stl_summary_flags, true); 674 AddCXXSummary(cpp_category_sp, 675 lldb_private::formatters::LibcxxContainerSummaryProvider, 676 "libc++ std::multimap summary provider", 677 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"), 678 stl_summary_flags, true); 679 AddCXXSummary( 680 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, 681 "libc++ std::unordered containers summary provider", 682 ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"), 683 stl_summary_flags, true); 684 AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider, 685 "libc++ std::tuple summary provider", 686 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"), 687 stl_summary_flags, true); 688 AddCXXSummary( 689 cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider, 690 "libc++ std::atomic summary provider", 691 ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_summary_flags, 692 true); 693 AddCXXSummary(cpp_category_sp, 694 lldb_private::formatters::LibcxxOptionalSummaryProvider, 695 "libc++ std::optional summary provider", 696 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"), 697 stl_summary_flags, true); 698 AddCXXSummary(cpp_category_sp, 699 lldb_private::formatters::LibcxxVariantSummaryProvider, 700 "libc++ std::variant summary provider", 701 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"), 702 stl_summary_flags, true); 703 704 stl_summary_flags.SetSkipPointers(true); 705 706 AddCXXSummary(cpp_category_sp, 707 lldb_private::formatters::LibcxxSmartPointerSummaryProvider, 708 "libc++ std::shared_ptr summary provider", 709 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"), 710 stl_summary_flags, true); 711 AddCXXSummary(cpp_category_sp, 712 lldb_private::formatters::LibcxxSmartPointerSummaryProvider, 713 "libc++ std::weak_ptr summary provider", 714 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"), 715 stl_summary_flags, true); 716 717 AddCXXSynthetic( 718 cpp_category_sp, 719 lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, 720 "std::vector iterator synthetic children", 721 ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags, 722 true); 723 724 AddCXXSynthetic( 725 cpp_category_sp, 726 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, 727 "std::map iterator synthetic children", 728 ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags, 729 true); 730} 731 732static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { 733 if (!cpp_category_sp) 734 return; 735 736 TypeSummaryImpl::Flags stl_summary_flags; 737 stl_summary_flags.SetCascades(true) 738 .SetSkipPointers(false) 739 .SetSkipReferences(false) 740 .SetDontShowChildren(true) 741 .SetDontShowValue(true) 742 .SetShowMembersOneLiner(false) 743 .SetHideItemNames(false); 744 745 lldb::TypeSummaryImplSP std_string_summary_sp( 746 new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}")); 747 748 lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat( 749 stl_summary_flags, LibStdcppStringSummaryProvider, 750 "libstdc++ c++11 std::string summary provider")); 751 lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat( 752 stl_summary_flags, LibStdcppWStringSummaryProvider, 753 "libstdc++ c++11 std::wstring summary provider")); 754 755 cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"), 756 std_string_summary_sp); 757 cpp_category_sp->GetTypeSummariesContainer()->Add( 758 ConstString("std::basic_string<char>"), std_string_summary_sp); 759 cpp_category_sp->GetTypeSummariesContainer()->Add( 760 ConstString("std::basic_string<char,std::char_traits<char>,std::" 761 "allocator<char> >"), 762 std_string_summary_sp); 763 cpp_category_sp->GetTypeSummariesContainer()->Add( 764 ConstString("std::basic_string<char, std::char_traits<char>, " 765 "std::allocator<char> >"), 766 std_string_summary_sp); 767 768 cpp_category_sp->GetTypeSummariesContainer()->Add( 769 ConstString("std::__cxx11::string"), cxx11_string_summary_sp); 770 cpp_category_sp->GetTypeSummariesContainer()->Add( 771 ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, " 772 "std::allocator<char> >"), 773 cxx11_string_summary_sp); 774 cpp_category_sp->GetTypeSummariesContainer()->Add( 775 ConstString("std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, " 776 "std::allocator<unsigned char> >"), 777 cxx11_string_summary_sp); 778 779 // making sure we force-pick the summary for printing wstring (_M_p is a 780 // wchar_t*) 781 lldb::TypeSummaryImplSP std_wstring_summary_sp( 782 new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}")); 783 784 cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"), 785 std_wstring_summary_sp); 786 cpp_category_sp->GetTypeSummariesContainer()->Add( 787 ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp); 788 cpp_category_sp->GetTypeSummariesContainer()->Add( 789 ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::" 790 "allocator<wchar_t> >"), 791 std_wstring_summary_sp); 792 cpp_category_sp->GetTypeSummariesContainer()->Add( 793 ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, " 794 "std::allocator<wchar_t> >"), 795 std_wstring_summary_sp); 796 797 cpp_category_sp->GetTypeSummariesContainer()->Add( 798 ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp); 799 cpp_category_sp->GetTypeSummariesContainer()->Add( 800 ConstString("std::__cxx11::basic_string<wchar_t, " 801 "std::char_traits<wchar_t>, std::allocator<wchar_t> >"), 802 cxx11_wstring_summary_sp); 803 804 SyntheticChildren::Flags stl_synth_flags; 805 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( 806 false); 807 808 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 809 RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")), 810 SyntheticChildrenSP(new ScriptedSyntheticChildren( 811 stl_synth_flags, 812 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); 813 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 814 RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")), 815 SyntheticChildrenSP(new ScriptedSyntheticChildren( 816 stl_synth_flags, 817 "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider"))); 818 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 819 RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")), 820 SyntheticChildrenSP(new ScriptedSyntheticChildren( 821 stl_synth_flags, 822 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider"))); 823 stl_summary_flags.SetDontShowChildren(false); 824 stl_summary_flags.SetSkipPointers(true); 825 cpp_category_sp->GetRegexTypeSummariesContainer()->Add( 826 RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")), 827 TypeSummaryImplSP( 828 new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); 829 cpp_category_sp->GetRegexTypeSummariesContainer()->Add( 830 RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")), 831 TypeSummaryImplSP( 832 new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); 833 cpp_category_sp->GetRegexTypeSummariesContainer()->Add( 834 RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")), 835 TypeSummaryImplSP( 836 new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); 837 838 AddCXXSynthetic( 839 cpp_category_sp, 840 lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, 841 "std::vector iterator synthetic children", 842 ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true); 843 844 AddCXXSynthetic( 845 cpp_category_sp, 846 lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, 847 "std::map iterator synthetic children", 848 ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true); 849 850 AddCXXSynthetic( 851 cpp_category_sp, 852 lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator, 853 "std::unique_ptr synthetic children", 854 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 855 AddCXXSynthetic( 856 cpp_category_sp, 857 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, 858 "std::shared_ptr synthetic children", 859 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 860 AddCXXSynthetic( 861 cpp_category_sp, 862 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, 863 "std::weak_ptr synthetic children", 864 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 865 AddCXXSynthetic( 866 cpp_category_sp, 867 lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator, 868 "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"), 869 stl_synth_flags, true); 870 871 AddCXXSummary(cpp_category_sp, 872 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider, 873 "libstdc++ std::unique_ptr summary provider", 874 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags, 875 true); 876 AddCXXSummary(cpp_category_sp, 877 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, 878 "libstdc++ std::shared_ptr summary provider", 879 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, 880 true); 881 AddCXXSummary(cpp_category_sp, 882 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, 883 "libstdc++ std::weak_ptr summary provider", 884 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, 885 true); 886} 887 888static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { 889 if (!cpp_category_sp) 890 return; 891 892 TypeSummaryImpl::Flags string_flags; 893 string_flags.SetCascades(true) 894 .SetSkipPointers(true) 895 .SetSkipReferences(false) 896 .SetDontShowChildren(true) 897 .SetDontShowValue(false) 898 .SetShowMembersOneLiner(false) 899 .SetHideItemNames(false); 900 901 TypeSummaryImpl::Flags string_array_flags; 902 string_array_flags.SetCascades(true) 903 .SetSkipPointers(true) 904 .SetSkipReferences(false) 905 .SetDontShowChildren(true) 906 .SetDontShowValue(true) 907 .SetShowMembersOneLiner(false) 908 .SetHideItemNames(false); 909 910 // FIXME because of a bug in the FormattersContainer we need to add a summary 911 // for both X* and const X* (<rdar://problem/12717717>) 912 AddCXXSummary( 913 cpp_category_sp, lldb_private::formatters::Char8StringSummaryProvider, 914 "char8_t * summary provider", ConstString("char8_t *"), string_flags); 915 AddCXXSummary(cpp_category_sp, 916 lldb_private::formatters::Char8StringSummaryProvider, 917 "char8_t [] summary provider", 918 ConstString("char8_t \\[[0-9]+\\]"), string_array_flags, true); 919 920 AddCXXSummary( 921 cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, 922 "char16_t * summary provider", ConstString("char16_t *"), string_flags); 923 AddCXXSummary(cpp_category_sp, 924 lldb_private::formatters::Char16StringSummaryProvider, 925 "char16_t [] summary provider", 926 ConstString("char16_t \\[[0-9]+\\]"), string_array_flags, true); 927 928 AddCXXSummary( 929 cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider, 930 "char32_t * summary provider", ConstString("char32_t *"), string_flags); 931 AddCXXSummary(cpp_category_sp, 932 lldb_private::formatters::Char32StringSummaryProvider, 933 "char32_t [] summary provider", 934 ConstString("char32_t \\[[0-9]+\\]"), string_array_flags, true); 935 936 AddCXXSummary( 937 cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, 938 "wchar_t * summary provider", ConstString("wchar_t *"), string_flags); 939 AddCXXSummary(cpp_category_sp, 940 lldb_private::formatters::WCharStringSummaryProvider, 941 "wchar_t * summary provider", 942 ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true); 943 944 AddCXXSummary( 945 cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, 946 "unichar * summary provider", ConstString("unichar *"), string_flags); 947 948 TypeSummaryImpl::Flags widechar_flags; 949 widechar_flags.SetDontShowValue(true) 950 .SetSkipPointers(true) 951 .SetSkipReferences(false) 952 .SetCascades(true) 953 .SetDontShowChildren(true) 954 .SetHideItemNames(true) 955 .SetShowMembersOneLiner(false); 956 957 AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider, 958 "char8_t summary provider", ConstString("char8_t"), 959 widechar_flags); 960 AddCXXSummary( 961 cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, 962 "char16_t summary provider", ConstString("char16_t"), widechar_flags); 963 AddCXXSummary( 964 cpp_category_sp, lldb_private::formatters::Char32SummaryProvider, 965 "char32_t summary provider", ConstString("char32_t"), widechar_flags); 966 AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider, 967 "wchar_t summary provider", ConstString("wchar_t"), 968 widechar_flags); 969 970 AddCXXSummary( 971 cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, 972 "unichar summary provider", ConstString("unichar"), widechar_flags); 973} 974 975std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() { 976 class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger { 977 public: 978 CompilerType AdjustForInclusion(CompilerType &candidate) override { 979 LanguageType lang_type(candidate.GetMinimumLanguage()); 980 if (!Language::LanguageIsC(lang_type) && 981 !Language::LanguageIsCPlusPlus(lang_type)) 982 return CompilerType(); 983 if (candidate.IsTypedefType()) 984 return candidate.GetTypedefedType(); 985 return candidate; 986 } 987 }; 988 989 return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger()); 990} 991 992lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() { 993 static llvm::once_flag g_initialize; 994 static TypeCategoryImplSP g_category; 995 996 llvm::call_once(g_initialize, [this]() -> void { 997 DataVisualization::Categories::GetCategory(GetPluginName(), g_category); 998 if (g_category) { 999 LoadLibStdcppFormatters(g_category); 1000 LoadLibCxxFormatters(g_category); 1001 LoadSystemFormatters(g_category); 1002 } 1003 }); 1004 return g_category; 1005} 1006 1007HardcodedFormatters::HardcodedSummaryFinder 1008CPlusPlusLanguage::GetHardcodedSummaries() { 1009 static llvm::once_flag g_initialize; 1010 static ConstString g_vectortypes("VectorTypes"); 1011 static HardcodedFormatters::HardcodedSummaryFinder g_formatters; 1012 1013 llvm::call_once(g_initialize, []() -> void { 1014 g_formatters.push_back( 1015 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, 1016 FormatManager &) -> TypeSummaryImpl::SharedPointer { 1017 static CXXFunctionSummaryFormat::SharedPointer formatter_sp( 1018 new CXXFunctionSummaryFormat( 1019 TypeSummaryImpl::Flags(), 1020 lldb_private::formatters::CXXFunctionPointerSummaryProvider, 1021 "Function pointer summary provider")); 1022 if (valobj.GetCompilerType().IsFunctionPointerType()) { 1023 return formatter_sp; 1024 } 1025 return nullptr; 1026 }); 1027 g_formatters.push_back( 1028 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, 1029 FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer { 1030 static CXXFunctionSummaryFormat::SharedPointer formatter_sp( 1031 new CXXFunctionSummaryFormat( 1032 TypeSummaryImpl::Flags() 1033 .SetCascades(true) 1034 .SetDontShowChildren(true) 1035 .SetHideItemNames(true) 1036 .SetShowMembersOneLiner(true) 1037 .SetSkipPointers(true) 1038 .SetSkipReferences(false), 1039 lldb_private::formatters::VectorTypeSummaryProvider, 1040 "vector_type pointer summary provider")); 1041 if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) { 1042 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) 1043 return formatter_sp; 1044 } 1045 return nullptr; 1046 }); 1047 g_formatters.push_back( 1048 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, 1049 FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer { 1050 static CXXFunctionSummaryFormat::SharedPointer formatter_sp( 1051 new CXXFunctionSummaryFormat( 1052 TypeSummaryImpl::Flags() 1053 .SetCascades(true) 1054 .SetDontShowChildren(true) 1055 .SetHideItemNames(true) 1056 .SetShowMembersOneLiner(true) 1057 .SetSkipPointers(true) 1058 .SetSkipReferences(false), 1059 lldb_private::formatters::BlockPointerSummaryProvider, 1060 "block pointer summary provider")); 1061 if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) { 1062 return formatter_sp; 1063 } 1064 return nullptr; 1065 }); 1066 }); 1067 1068 return g_formatters; 1069} 1070 1071HardcodedFormatters::HardcodedSyntheticFinder 1072CPlusPlusLanguage::GetHardcodedSynthetics() { 1073 static llvm::once_flag g_initialize; 1074 static ConstString g_vectortypes("VectorTypes"); 1075 static HardcodedFormatters::HardcodedSyntheticFinder g_formatters; 1076 1077 llvm::call_once(g_initialize, []() -> void { 1078 g_formatters.push_back([](lldb_private::ValueObject &valobj, 1079 lldb::DynamicValueType, 1080 FormatManager & 1081 fmt_mgr) -> SyntheticChildren::SharedPointer { 1082 static CXXSyntheticChildren::SharedPointer formatter_sp( 1083 new CXXSyntheticChildren( 1084 SyntheticChildren::Flags() 1085 .SetCascades(true) 1086 .SetSkipPointers(true) 1087 .SetSkipReferences(true) 1088 .SetNonCacheable(true), 1089 "vector_type synthetic children", 1090 lldb_private::formatters::VectorTypeSyntheticFrontEndCreator)); 1091 if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) { 1092 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) 1093 return formatter_sp; 1094 } 1095 return nullptr; 1096 }); 1097 g_formatters.push_back([](lldb_private::ValueObject &valobj, 1098 lldb::DynamicValueType, 1099 FormatManager & 1100 fmt_mgr) -> SyntheticChildren::SharedPointer { 1101 static CXXSyntheticChildren::SharedPointer formatter_sp( 1102 new CXXSyntheticChildren( 1103 SyntheticChildren::Flags() 1104 .SetCascades(true) 1105 .SetSkipPointers(true) 1106 .SetSkipReferences(true) 1107 .SetNonCacheable(true), 1108 "block pointer synthetic children", 1109 lldb_private::formatters::BlockPointerSyntheticFrontEndCreator)); 1110 if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) { 1111 return formatter_sp; 1112 } 1113 return nullptr; 1114 }); 1115 1116 }); 1117 1118 return g_formatters; 1119} 1120 1121bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const { 1122 const auto suffixes = {".cpp", ".cxx", ".c++", ".cc", ".c", 1123 ".h", ".hh", ".hpp", ".hxx", ".h++"}; 1124 for (auto suffix : suffixes) { 1125 if (file_path.endswith_lower(suffix)) 1126 return true; 1127 } 1128 1129 // Check if we're in a STL path (where the files usually have no extension 1130 // that we could check for. 1131 return file_path.contains("/usr/include/c++/"); 1132} 1133