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