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 42 using namespace lldb; 43 using namespace lldb_private; 44 using namespace lldb_private::formatters; 45 46 void CPlusPlusLanguage::Initialize() { 47 PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language", 48 CreateInstance); 49 } 50 51 void CPlusPlusLanguage::Terminate() { 52 PluginManager::UnregisterPlugin(CreateInstance); 53 } 54 55 lldb_private::ConstString CPlusPlusLanguage::GetPluginNameStatic() { 56 static ConstString g_name("cplusplus"); 57 return g_name; 58 } 59 60 // PluginInterface protocol 61 62 lldb_private::ConstString CPlusPlusLanguage::GetPluginName() { 63 return GetPluginNameStatic(); 64 } 65 66 uint32_t CPlusPlusLanguage::GetPluginVersion() { return 1; } 67 68 // Static Functions 69 70 Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) { 71 if (Language::LanguageIsCPlusPlus(language)) 72 return new CPlusPlusLanguage(); 73 return nullptr; 74 } 75 76 void 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 86 static 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 115 static 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 143 bool 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 185 void 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 205 llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() { 206 if (!m_parsed) 207 Parse(); 208 return m_basename; 209 } 210 211 llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() { 212 if (!m_parsed) 213 Parse(); 214 return m_context; 215 } 216 217 llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() { 218 if (!m_parsed) 219 Parse(); 220 return m_arguments; 221 } 222 223 llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() { 224 if (!m_parsed) 225 Parse(); 226 return m_qualifiers; 227 } 228 229 std::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 242 bool 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 254 bool 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 269 namespace { 270 class NodeAllocator { 271 llvm::BumpPtrAllocator Alloc; 272 273 public: 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 287 /// Given a mangled function `Mangled`, replace all the primitive function type 288 /// arguments of `Search` with type `Replace`. 289 class TypeSubstitutor 290 : public llvm::itanium_demangle::AbstractManglingParser<TypeSubstitutor, 291 NodeAllocator> { 292 /// Input character until which we have constructed the respective output 293 /// already 294 const char *Written; 295 296 llvm::StringRef Search; 297 llvm::StringRef Replace; 298 llvm::SmallString<128> Result; 299 300 /// Whether we have performed any substitutions. 301 bool Substituted; 302 303 void reset(llvm::StringRef Mangled, llvm::StringRef Search, 304 llvm::StringRef Replace) { 305 AbstractManglingParser::reset(Mangled.begin(), Mangled.end()); 306 Written = Mangled.begin(); 307 this->Search = Search; 308 this->Replace = Replace; 309 Result.clear(); 310 Substituted = false; 311 } 312 313 void appendUnchangedInput() { 314 Result += llvm::StringRef(Written, First - Written); 315 Written = First; 316 } 317 318 public: 319 TypeSubstitutor() : AbstractManglingParser(nullptr, nullptr) {} 320 321 ConstString substitute(llvm::StringRef Mangled, llvm::StringRef From, 322 llvm::StringRef To) { 323 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); 324 325 reset(Mangled, From, To); 326 if (parse() == nullptr) { 327 LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled); 328 return ConstString(); 329 } 330 if (!Substituted) 331 return ConstString(); 332 333 // Append any trailing unmodified input. 334 appendUnchangedInput(); 335 LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result); 336 return ConstString(Result); 337 } 338 339 llvm::itanium_demangle::Node *parseType() { 340 if (llvm::StringRef(First, numLeft()).startswith(Search)) { 341 // We found a match. Append unmodified input up to this point. 342 appendUnchangedInput(); 343 344 // And then perform the replacement. 345 Result += Replace; 346 Written += Search.size(); 347 Substituted = true; 348 } 349 return AbstractManglingParser::parseType(); 350 } 351 }; 352 } 353 354 uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( 355 const ConstString mangled_name, std::set<ConstString> &alternates) { 356 const auto start_size = alternates.size(); 357 /// Get a basic set of alternative manglings for the given symbol `name`, by 358 /// making a few basic possible substitutions on basic types, storage duration 359 /// and `const`ness for the given symbol. The output parameter `alternates` 360 /// is filled with a best-guess, non-exhaustive set of different manglings 361 /// for the given name. 362 363 // Maybe we're looking for a const symbol but the debug info told us it was 364 // non-const... 365 if (!strncmp(mangled_name.GetCString(), "_ZN", 3) && 366 strncmp(mangled_name.GetCString(), "_ZNK", 4)) { 367 std::string fixed_scratch("_ZNK"); 368 fixed_scratch.append(mangled_name.GetCString() + 3); 369 alternates.insert(ConstString(fixed_scratch)); 370 } 371 372 // Maybe we're looking for a static symbol but we thought it was global... 373 if (!strncmp(mangled_name.GetCString(), "_Z", 2) && 374 strncmp(mangled_name.GetCString(), "_ZL", 3)) { 375 std::string fixed_scratch("_ZL"); 376 fixed_scratch.append(mangled_name.GetCString() + 2); 377 alternates.insert(ConstString(fixed_scratch)); 378 } 379 380 TypeSubstitutor TS; 381 // `char` is implementation defined as either `signed` or `unsigned`. As a 382 // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed 383 // char, 'h'-unsigned char. If we're looking for symbols with a signed char 384 // parameter, try finding matches which have the general case 'c'. 385 if (ConstString char_fixup = 386 TS.substitute(mangled_name.GetStringRef(), "a", "c")) 387 alternates.insert(char_fixup); 388 389 // long long parameter mangling 'x', may actually just be a long 'l' argument 390 if (ConstString long_fixup = 391 TS.substitute(mangled_name.GetStringRef(), "x", "l")) 392 alternates.insert(long_fixup); 393 394 // unsigned long long parameter mangling 'y', may actually just be unsigned 395 // long 'm' argument 396 if (ConstString ulong_fixup = 397 TS.substitute(mangled_name.GetStringRef(), "y", "m")) 398 alternates.insert(ulong_fixup); 399 400 return alternates.size() - start_size; 401 } 402 403 static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { 404 if (!cpp_category_sp) 405 return; 406 407 TypeSummaryImpl::Flags stl_summary_flags; 408 stl_summary_flags.SetCascades(true) 409 .SetSkipPointers(false) 410 .SetSkipReferences(false) 411 .SetDontShowChildren(true) 412 .SetDontShowValue(true) 413 .SetShowMembersOneLiner(false) 414 .SetHideItemNames(false); 415 416 AddCXXSummary(cpp_category_sp, 417 lldb_private::formatters::LibcxxStringSummaryProviderASCII, 418 "std::string summary provider", 419 ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags, 420 true); 421 AddCXXSummary(cpp_category_sp, 422 lldb_private::formatters::LibcxxStringSummaryProviderASCII, 423 "std::string summary provider", 424 ConstString("^std::__[[:alnum:]]+::basic_string<char, " 425 "std::__[[:alnum:]]+::char_traits<char>, " 426 "std::__[[:alnum:]]+::allocator<char> >$"), 427 stl_summary_flags, true); 428 429 AddCXXSummary(cpp_category_sp, 430 lldb_private::formatters::LibcxxStringSummaryProviderUTF16, 431 "std::u16string summary provider", 432 ConstString( 433 "^std::__[[:alnum:]]+::basic_string<char16_t, " 434 "std::__[[:alnum:]]+::char_traits<char16_t>, " 435 "std::__[[:alnum:]]+::allocator<char16_t> >$"), 436 stl_summary_flags, true); 437 438 AddCXXSummary(cpp_category_sp, 439 lldb_private::formatters::LibcxxStringSummaryProviderUTF32, 440 "std::u32string summary provider", 441 ConstString( 442 "^std::__[[:alnum:]]+::basic_string<char32_t, " 443 "std::__[[:alnum:]]+::char_traits<char32_t>, " 444 "std::__[[:alnum:]]+::allocator<char32_t> >$"), 445 stl_summary_flags, true); 446 447 AddCXXSummary(cpp_category_sp, 448 lldb_private::formatters::LibcxxWStringSummaryProvider, 449 "std::wstring summary provider", 450 ConstString("^std::__[[:alnum:]]+::wstring$"), 451 stl_summary_flags, true); 452 AddCXXSummary(cpp_category_sp, 453 lldb_private::formatters::LibcxxWStringSummaryProvider, 454 "std::wstring summary provider", 455 ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, " 456 "std::__[[:alnum:]]+::char_traits<wchar_t>, " 457 "std::__[[:alnum:]]+::allocator<wchar_t> >$"), 458 stl_summary_flags, true); 459 460 SyntheticChildren::Flags stl_synth_flags; 461 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( 462 false); 463 SyntheticChildren::Flags stl_deref_flags = stl_synth_flags; 464 stl_deref_flags.SetFrontEndWantsDereference(); 465 466 AddCXXSynthetic( 467 cpp_category_sp, 468 lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator, 469 "libc++ std::bitset synthetic children", 470 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags, 471 true); 472 AddCXXSynthetic( 473 cpp_category_sp, 474 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, 475 "libc++ std::vector synthetic children", 476 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags, 477 true); 478 AddCXXSynthetic( 479 cpp_category_sp, 480 lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator, 481 "libc++ std::forward_list synthetic children", 482 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"), 483 stl_synth_flags, true); 484 AddCXXSynthetic( 485 cpp_category_sp, 486 lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, 487 "libc++ std::list synthetic children", 488 // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$" 489 // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$" 490 ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|" 491 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"), 492 stl_deref_flags, true); 493 AddCXXSynthetic( 494 cpp_category_sp, 495 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 496 "libc++ std::map synthetic children", 497 ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags, 498 true); 499 AddCXXSynthetic( 500 cpp_category_sp, 501 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 502 "libc++ std::set synthetic children", 503 ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags, 504 true); 505 AddCXXSynthetic( 506 cpp_category_sp, 507 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 508 "libc++ std::multiset synthetic children", 509 ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"), 510 stl_deref_flags, true); 511 AddCXXSynthetic( 512 cpp_category_sp, 513 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, 514 "libc++ std::multimap synthetic children", 515 ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"), 516 stl_synth_flags, true); 517 AddCXXSynthetic( 518 cpp_category_sp, 519 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, 520 "libc++ std::unordered containers synthetic children", 521 ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"), 522 stl_synth_flags, true); 523 AddCXXSynthetic( 524 cpp_category_sp, 525 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, 526 "libc++ std::initializer_list synthetic children", 527 ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags, 528 true); 529 AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator, 530 "libc++ std::queue synthetic children", 531 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"), 532 stl_synth_flags, true); 533 AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator, 534 "libc++ std::tuple synthetic children", 535 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"), 536 stl_synth_flags, true); 537 AddCXXSynthetic(cpp_category_sp, LibcxxOptionalFrontEndCreator, 538 "libc++ std::optional synthetic children", 539 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"), 540 stl_synth_flags, true); 541 AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator, 542 "libc++ std::variant synthetic children", 543 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"), 544 stl_synth_flags, true); 545 AddCXXSynthetic( 546 cpp_category_sp, 547 lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator, 548 "libc++ std::atomic synthetic children", 549 ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true); 550 551 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 552 RegularExpression( 553 llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$")), 554 SyntheticChildrenSP(new ScriptedSyntheticChildren( 555 stl_synth_flags, 556 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider"))); 557 558 AddCXXSynthetic( 559 cpp_category_sp, 560 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, 561 "shared_ptr synthetic children", 562 ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"), 563 stl_synth_flags, true); 564 AddCXXSynthetic( 565 cpp_category_sp, 566 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, 567 "weak_ptr synthetic children", 568 ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"), 569 stl_synth_flags, true); 570 571 stl_summary_flags.SetDontShowChildren(false); 572 stl_summary_flags.SetSkipPointers(false); 573 AddCXXSummary(cpp_category_sp, 574 lldb_private::formatters::LibcxxContainerSummaryProvider, 575 "libc++ std::bitset summary provider", 576 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), 577 stl_summary_flags, true); 578 AddCXXSummary(cpp_category_sp, 579 lldb_private::formatters::LibcxxContainerSummaryProvider, 580 "libc++ std::vector summary provider", 581 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), 582 stl_summary_flags, true); 583 AddCXXSummary(cpp_category_sp, 584 lldb_private::formatters::LibcxxContainerSummaryProvider, 585 "libc++ std::list summary provider", 586 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"), 587 stl_summary_flags, true); 588 AddCXXSummary( 589 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, 590 "libc++ std::list summary provider", 591 // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$" 592 // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$" 593 ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|" 594 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"), 595 stl_summary_flags, true); 596 AddCXXSummary(cpp_category_sp, 597 lldb_private::formatters::LibcxxContainerSummaryProvider, 598 "libc++ std::map summary provider", 599 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"), 600 stl_summary_flags, true); 601 AddCXXSummary(cpp_category_sp, 602 lldb_private::formatters::LibcxxContainerSummaryProvider, 603 "libc++ std::deque summary provider", 604 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"), 605 stl_summary_flags, true); 606 AddCXXSummary(cpp_category_sp, 607 lldb_private::formatters::LibcxxContainerSummaryProvider, 608 "libc++ std::queue summary provider", 609 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"), 610 stl_summary_flags, true); 611 AddCXXSummary(cpp_category_sp, 612 lldb_private::formatters::LibcxxContainerSummaryProvider, 613 "libc++ std::set summary provider", 614 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"), 615 stl_summary_flags, true); 616 AddCXXSummary(cpp_category_sp, 617 lldb_private::formatters::LibcxxContainerSummaryProvider, 618 "libc++ std::multiset summary provider", 619 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"), 620 stl_summary_flags, true); 621 AddCXXSummary(cpp_category_sp, 622 lldb_private::formatters::LibcxxContainerSummaryProvider, 623 "libc++ std::multimap summary provider", 624 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"), 625 stl_summary_flags, true); 626 AddCXXSummary( 627 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, 628 "libc++ std::unordered containers summary provider", 629 ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"), 630 stl_summary_flags, true); 631 AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider, 632 "libc++ std::tuple summary provider", 633 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"), 634 stl_summary_flags, true); 635 AddCXXSummary( 636 cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider, 637 "libc++ std::atomic summary provider", 638 ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_summary_flags, 639 true); 640 AddCXXSummary(cpp_category_sp, 641 lldb_private::formatters::LibcxxOptionalSummaryProvider, 642 "libc++ std::optional summary provider", 643 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"), 644 stl_summary_flags, true); 645 AddCXXSummary(cpp_category_sp, 646 lldb_private::formatters::LibcxxVariantSummaryProvider, 647 "libc++ std::variant summary provider", 648 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"), 649 stl_summary_flags, true); 650 651 stl_summary_flags.SetSkipPointers(true); 652 653 AddCXXSummary(cpp_category_sp, 654 lldb_private::formatters::LibcxxSmartPointerSummaryProvider, 655 "libc++ std::shared_ptr summary provider", 656 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"), 657 stl_summary_flags, true); 658 AddCXXSummary(cpp_category_sp, 659 lldb_private::formatters::LibcxxSmartPointerSummaryProvider, 660 "libc++ std::weak_ptr summary provider", 661 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"), 662 stl_summary_flags, true); 663 664 AddCXXSynthetic( 665 cpp_category_sp, 666 lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, 667 "std::vector iterator synthetic children", 668 ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags, 669 true); 670 671 AddCXXSynthetic( 672 cpp_category_sp, 673 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, 674 "std::map iterator synthetic children", 675 ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags, 676 true); 677 } 678 679 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { 680 if (!cpp_category_sp) 681 return; 682 683 TypeSummaryImpl::Flags stl_summary_flags; 684 stl_summary_flags.SetCascades(true) 685 .SetSkipPointers(false) 686 .SetSkipReferences(false) 687 .SetDontShowChildren(true) 688 .SetDontShowValue(true) 689 .SetShowMembersOneLiner(false) 690 .SetHideItemNames(false); 691 692 lldb::TypeSummaryImplSP std_string_summary_sp( 693 new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}")); 694 695 lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat( 696 stl_summary_flags, LibStdcppStringSummaryProvider, 697 "libstdc++ c++11 std::string summary provider")); 698 lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat( 699 stl_summary_flags, LibStdcppWStringSummaryProvider, 700 "libstdc++ c++11 std::wstring summary provider")); 701 702 cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"), 703 std_string_summary_sp); 704 cpp_category_sp->GetTypeSummariesContainer()->Add( 705 ConstString("std::basic_string<char>"), std_string_summary_sp); 706 cpp_category_sp->GetTypeSummariesContainer()->Add( 707 ConstString("std::basic_string<char,std::char_traits<char>,std::" 708 "allocator<char> >"), 709 std_string_summary_sp); 710 cpp_category_sp->GetTypeSummariesContainer()->Add( 711 ConstString("std::basic_string<char, std::char_traits<char>, " 712 "std::allocator<char> >"), 713 std_string_summary_sp); 714 715 cpp_category_sp->GetTypeSummariesContainer()->Add( 716 ConstString("std::__cxx11::string"), cxx11_string_summary_sp); 717 cpp_category_sp->GetTypeSummariesContainer()->Add( 718 ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, " 719 "std::allocator<char> >"), 720 cxx11_string_summary_sp); 721 722 // making sure we force-pick the summary for printing wstring (_M_p is a 723 // wchar_t*) 724 lldb::TypeSummaryImplSP std_wstring_summary_sp( 725 new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}")); 726 727 cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"), 728 std_wstring_summary_sp); 729 cpp_category_sp->GetTypeSummariesContainer()->Add( 730 ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp); 731 cpp_category_sp->GetTypeSummariesContainer()->Add( 732 ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::" 733 "allocator<wchar_t> >"), 734 std_wstring_summary_sp); 735 cpp_category_sp->GetTypeSummariesContainer()->Add( 736 ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, " 737 "std::allocator<wchar_t> >"), 738 std_wstring_summary_sp); 739 740 cpp_category_sp->GetTypeSummariesContainer()->Add( 741 ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp); 742 cpp_category_sp->GetTypeSummariesContainer()->Add( 743 ConstString("std::__cxx11::basic_string<wchar_t, " 744 "std::char_traits<wchar_t>, std::allocator<wchar_t> >"), 745 cxx11_wstring_summary_sp); 746 747 SyntheticChildren::Flags stl_synth_flags; 748 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( 749 false); 750 751 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 752 RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")), 753 SyntheticChildrenSP(new ScriptedSyntheticChildren( 754 stl_synth_flags, 755 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); 756 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 757 RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")), 758 SyntheticChildrenSP(new ScriptedSyntheticChildren( 759 stl_synth_flags, 760 "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider"))); 761 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( 762 RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")), 763 SyntheticChildrenSP(new ScriptedSyntheticChildren( 764 stl_synth_flags, 765 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider"))); 766 stl_summary_flags.SetDontShowChildren(false); 767 stl_summary_flags.SetSkipPointers(true); 768 cpp_category_sp->GetRegexTypeSummariesContainer()->Add( 769 RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")), 770 TypeSummaryImplSP( 771 new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); 772 cpp_category_sp->GetRegexTypeSummariesContainer()->Add( 773 RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")), 774 TypeSummaryImplSP( 775 new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); 776 cpp_category_sp->GetRegexTypeSummariesContainer()->Add( 777 RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")), 778 TypeSummaryImplSP( 779 new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); 780 781 AddCXXSynthetic( 782 cpp_category_sp, 783 lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, 784 "std::vector iterator synthetic children", 785 ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true); 786 787 AddCXXSynthetic( 788 cpp_category_sp, 789 lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, 790 "std::map iterator synthetic children", 791 ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true); 792 793 AddCXXSynthetic( 794 cpp_category_sp, 795 lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator, 796 "std::unique_ptr synthetic children", 797 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 798 AddCXXSynthetic( 799 cpp_category_sp, 800 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, 801 "std::shared_ptr synthetic children", 802 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 803 AddCXXSynthetic( 804 cpp_category_sp, 805 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, 806 "std::weak_ptr synthetic children", 807 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 808 AddCXXSynthetic( 809 cpp_category_sp, 810 lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator, 811 "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"), 812 stl_synth_flags, true); 813 814 AddCXXSummary(cpp_category_sp, 815 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider, 816 "libstdc++ std::unique_ptr summary provider", 817 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags, 818 true); 819 AddCXXSummary(cpp_category_sp, 820 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, 821 "libstdc++ std::shared_ptr summary provider", 822 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, 823 true); 824 AddCXXSummary(cpp_category_sp, 825 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, 826 "libstdc++ std::weak_ptr summary provider", 827 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, 828 true); 829 } 830 831 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { 832 if (!cpp_category_sp) 833 return; 834 835 TypeSummaryImpl::Flags string_flags; 836 string_flags.SetCascades(true) 837 .SetSkipPointers(true) 838 .SetSkipReferences(false) 839 .SetDontShowChildren(true) 840 .SetDontShowValue(false) 841 .SetShowMembersOneLiner(false) 842 .SetHideItemNames(false); 843 844 TypeSummaryImpl::Flags string_array_flags; 845 string_array_flags.SetCascades(true) 846 .SetSkipPointers(true) 847 .SetSkipReferences(false) 848 .SetDontShowChildren(true) 849 .SetDontShowValue(true) 850 .SetShowMembersOneLiner(false) 851 .SetHideItemNames(false); 852 853 // FIXME because of a bug in the FormattersContainer we need to add a summary 854 // for both X* and const X* (<rdar://problem/12717717>) 855 AddCXXSummary( 856 cpp_category_sp, lldb_private::formatters::Char8StringSummaryProvider, 857 "char8_t * summary provider", ConstString("char8_t *"), string_flags); 858 AddCXXSummary(cpp_category_sp, 859 lldb_private::formatters::Char8StringSummaryProvider, 860 "char8_t [] summary provider", 861 ConstString("char8_t \\[[0-9]+\\]"), string_array_flags, true); 862 863 AddCXXSummary( 864 cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, 865 "char16_t * summary provider", ConstString("char16_t *"), string_flags); 866 AddCXXSummary(cpp_category_sp, 867 lldb_private::formatters::Char16StringSummaryProvider, 868 "char16_t [] summary provider", 869 ConstString("char16_t \\[[0-9]+\\]"), string_array_flags, true); 870 871 AddCXXSummary( 872 cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider, 873 "char32_t * summary provider", ConstString("char32_t *"), string_flags); 874 AddCXXSummary(cpp_category_sp, 875 lldb_private::formatters::Char32StringSummaryProvider, 876 "char32_t [] summary provider", 877 ConstString("char32_t \\[[0-9]+\\]"), string_array_flags, true); 878 879 AddCXXSummary( 880 cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, 881 "wchar_t * summary provider", ConstString("wchar_t *"), string_flags); 882 AddCXXSummary(cpp_category_sp, 883 lldb_private::formatters::WCharStringSummaryProvider, 884 "wchar_t * summary provider", 885 ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true); 886 887 AddCXXSummary( 888 cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, 889 "unichar * summary provider", ConstString("unichar *"), string_flags); 890 891 TypeSummaryImpl::Flags widechar_flags; 892 widechar_flags.SetDontShowValue(true) 893 .SetSkipPointers(true) 894 .SetSkipReferences(false) 895 .SetCascades(true) 896 .SetDontShowChildren(true) 897 .SetHideItemNames(true) 898 .SetShowMembersOneLiner(false); 899 900 AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider, 901 "char8_t summary provider", ConstString("char8_t"), 902 widechar_flags); 903 AddCXXSummary( 904 cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, 905 "char16_t summary provider", ConstString("char16_t"), widechar_flags); 906 AddCXXSummary( 907 cpp_category_sp, lldb_private::formatters::Char32SummaryProvider, 908 "char32_t summary provider", ConstString("char32_t"), widechar_flags); 909 AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider, 910 "wchar_t summary provider", ConstString("wchar_t"), 911 widechar_flags); 912 913 AddCXXSummary( 914 cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, 915 "unichar summary provider", ConstString("unichar"), widechar_flags); 916 } 917 918 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() { 919 class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger { 920 public: 921 CompilerType AdjustForInclusion(CompilerType &candidate) override { 922 LanguageType lang_type(candidate.GetMinimumLanguage()); 923 if (!Language::LanguageIsC(lang_type) && 924 !Language::LanguageIsCPlusPlus(lang_type)) 925 return CompilerType(); 926 if (candidate.IsTypedefType()) 927 return candidate.GetTypedefedType(); 928 return candidate; 929 } 930 }; 931 932 return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger()); 933 } 934 935 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() { 936 static llvm::once_flag g_initialize; 937 static TypeCategoryImplSP g_category; 938 939 llvm::call_once(g_initialize, [this]() -> void { 940 DataVisualization::Categories::GetCategory(GetPluginName(), g_category); 941 if (g_category) { 942 LoadLibStdcppFormatters(g_category); 943 LoadLibCxxFormatters(g_category); 944 LoadSystemFormatters(g_category); 945 } 946 }); 947 return g_category; 948 } 949 950 HardcodedFormatters::HardcodedSummaryFinder 951 CPlusPlusLanguage::GetHardcodedSummaries() { 952 static llvm::once_flag g_initialize; 953 static ConstString g_vectortypes("VectorTypes"); 954 static HardcodedFormatters::HardcodedSummaryFinder g_formatters; 955 956 llvm::call_once(g_initialize, []() -> void { 957 g_formatters.push_back( 958 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, 959 FormatManager &) -> TypeSummaryImpl::SharedPointer { 960 static CXXFunctionSummaryFormat::SharedPointer formatter_sp( 961 new CXXFunctionSummaryFormat( 962 TypeSummaryImpl::Flags(), 963 lldb_private::formatters::CXXFunctionPointerSummaryProvider, 964 "Function pointer summary provider")); 965 if (valobj.GetCompilerType().IsFunctionPointerType()) { 966 return formatter_sp; 967 } 968 return nullptr; 969 }); 970 g_formatters.push_back( 971 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, 972 FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer { 973 static CXXFunctionSummaryFormat::SharedPointer formatter_sp( 974 new CXXFunctionSummaryFormat( 975 TypeSummaryImpl::Flags() 976 .SetCascades(true) 977 .SetDontShowChildren(true) 978 .SetHideItemNames(true) 979 .SetShowMembersOneLiner(true) 980 .SetSkipPointers(true) 981 .SetSkipReferences(false), 982 lldb_private::formatters::VectorTypeSummaryProvider, 983 "vector_type pointer summary provider")); 984 if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) { 985 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) 986 return formatter_sp; 987 } 988 return nullptr; 989 }); 990 g_formatters.push_back( 991 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, 992 FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer { 993 static CXXFunctionSummaryFormat::SharedPointer formatter_sp( 994 new CXXFunctionSummaryFormat( 995 TypeSummaryImpl::Flags() 996 .SetCascades(true) 997 .SetDontShowChildren(true) 998 .SetHideItemNames(true) 999 .SetShowMembersOneLiner(true) 1000 .SetSkipPointers(true) 1001 .SetSkipReferences(false), 1002 lldb_private::formatters::BlockPointerSummaryProvider, 1003 "block pointer summary provider")); 1004 if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) { 1005 return formatter_sp; 1006 } 1007 return nullptr; 1008 }); 1009 }); 1010 1011 return g_formatters; 1012 } 1013 1014 HardcodedFormatters::HardcodedSyntheticFinder 1015 CPlusPlusLanguage::GetHardcodedSynthetics() { 1016 static llvm::once_flag g_initialize; 1017 static ConstString g_vectortypes("VectorTypes"); 1018 static HardcodedFormatters::HardcodedSyntheticFinder g_formatters; 1019 1020 llvm::call_once(g_initialize, []() -> void { 1021 g_formatters.push_back([](lldb_private::ValueObject &valobj, 1022 lldb::DynamicValueType, 1023 FormatManager & 1024 fmt_mgr) -> SyntheticChildren::SharedPointer { 1025 static CXXSyntheticChildren::SharedPointer formatter_sp( 1026 new CXXSyntheticChildren( 1027 SyntheticChildren::Flags() 1028 .SetCascades(true) 1029 .SetSkipPointers(true) 1030 .SetSkipReferences(true) 1031 .SetNonCacheable(true), 1032 "vector_type synthetic children", 1033 lldb_private::formatters::VectorTypeSyntheticFrontEndCreator)); 1034 if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) { 1035 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) 1036 return formatter_sp; 1037 } 1038 return nullptr; 1039 }); 1040 g_formatters.push_back([](lldb_private::ValueObject &valobj, 1041 lldb::DynamicValueType, 1042 FormatManager & 1043 fmt_mgr) -> SyntheticChildren::SharedPointer { 1044 static CXXSyntheticChildren::SharedPointer formatter_sp( 1045 new CXXSyntheticChildren( 1046 SyntheticChildren::Flags() 1047 .SetCascades(true) 1048 .SetSkipPointers(true) 1049 .SetSkipReferences(true) 1050 .SetNonCacheable(true), 1051 "block pointer synthetic children", 1052 lldb_private::formatters::BlockPointerSyntheticFrontEndCreator)); 1053 if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) { 1054 return formatter_sp; 1055 } 1056 return nullptr; 1057 }); 1058 1059 }); 1060 1061 return g_formatters; 1062 } 1063 1064 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const { 1065 const auto suffixes = {".cpp", ".cxx", ".c++", ".cc", ".c", 1066 ".h", ".hh", ".hpp", ".hxx", ".h++"}; 1067 for (auto suffix : suffixes) { 1068 if (file_path.endswith_lower(suffix)) 1069 return true; 1070 } 1071 1072 // Check if we're in a STL path (where the files usually have no extension 1073 // that we could check for. 1074 return file_path.contains("/usr/include/c++/"); 1075 } 1076