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   AddCXXSummary(cpp_category_sp,
423                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
424                 "std::string summary provider",
425                 ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags,
426                 true);
427   AddCXXSummary(cpp_category_sp,
428                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
429                 "std::string summary provider",
430                 ConstString("^std::__[[:alnum:]]+::basic_string<char, "
431                             "std::__[[:alnum:]]+::char_traits<char>, "
432                             "std::__[[:alnum:]]+::allocator<char> >$"),
433                 stl_summary_flags, true);
434 
435   AddCXXSummary(cpp_category_sp,
436                 lldb_private::formatters::LibcxxStringSummaryProviderUTF16,
437                 "std::u16string summary provider",
438                 ConstString(
439                     "^std::__[[:alnum:]]+::basic_string<char16_t, "
440                     "std::__[[:alnum:]]+::char_traits<char16_t>, "
441                     "std::__[[:alnum:]]+::allocator<char16_t> >$"),
442                 stl_summary_flags, true);
443 
444   AddCXXSummary(cpp_category_sp,
445                 lldb_private::formatters::LibcxxStringSummaryProviderUTF32,
446                 "std::u32string summary provider",
447                 ConstString(
448                     "^std::__[[:alnum:]]+::basic_string<char32_t, "
449                     "std::__[[:alnum:]]+::char_traits<char32_t>, "
450                     "std::__[[:alnum:]]+::allocator<char32_t> >$"),
451                 stl_summary_flags, true);
452 
453   AddCXXSummary(cpp_category_sp,
454                 lldb_private::formatters::LibcxxWStringSummaryProvider,
455                 "std::wstring summary provider",
456                 ConstString("^std::__[[:alnum:]]+::wstring$"),
457                 stl_summary_flags, true);
458   AddCXXSummary(cpp_category_sp,
459                 lldb_private::formatters::LibcxxWStringSummaryProvider,
460                 "std::wstring summary provider",
461                 ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, "
462                             "std::__[[:alnum:]]+::char_traits<wchar_t>, "
463                             "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
464                 stl_summary_flags, true);
465 
466   SyntheticChildren::Flags stl_synth_flags;
467   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
468       false);
469   SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
470   stl_deref_flags.SetFrontEndWantsDereference();
471 
472   AddCXXSynthetic(
473       cpp_category_sp,
474       lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
475       "libc++ std::bitset synthetic children",
476       ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
477       true);
478   AddCXXSynthetic(
479       cpp_category_sp,
480       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
481       "libc++ std::vector synthetic children",
482       ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
483       true);
484   AddCXXSynthetic(
485       cpp_category_sp,
486       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
487       "libc++ std::forward_list synthetic children",
488       ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
489       stl_synth_flags, true);
490   AddCXXSynthetic(
491       cpp_category_sp,
492       lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
493       "libc++ std::list synthetic children",
494       ConstString("^std::__[[:alnum:]]+::list<.+>(( )?&)?$"), stl_synth_flags,
495       true);
496   AddCXXSynthetic(
497       cpp_category_sp,
498       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
499       "libc++ std::map synthetic children",
500       ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
501       true);
502   AddCXXSynthetic(
503       cpp_category_sp,
504       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
505       "libc++ std::set synthetic children",
506       ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
507       true);
508   AddCXXSynthetic(
509       cpp_category_sp,
510       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
511       "libc++ std::multiset synthetic children",
512       ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
513       stl_deref_flags, true);
514   AddCXXSynthetic(
515       cpp_category_sp,
516       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
517       "libc++ std::multimap synthetic children",
518       ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
519       stl_synth_flags, true);
520   AddCXXSynthetic(
521       cpp_category_sp,
522       lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator,
523       "libc++ std::unordered containers synthetic children",
524       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
525       stl_synth_flags, true);
526   AddCXXSynthetic(
527       cpp_category_sp,
528       lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
529       "libc++ std::initializer_list synthetic children",
530       ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
531       true);
532   AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator,
533                   "libc++ std::queue synthetic children",
534                   ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
535                   stl_synth_flags, true);
536   AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
537                   "libc++ std::tuple synthetic children",
538                   ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
539                   stl_synth_flags, true);
540   AddCXXSynthetic(cpp_category_sp, LibcxxOptionalFrontEndCreator,
541                   "libc++ std::optional synthetic children",
542                   ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
543                   stl_synth_flags, true);
544   AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
545                   "libc++ std::variant synthetic children",
546                   ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
547                   stl_synth_flags, true);
548   AddCXXSynthetic(
549       cpp_category_sp,
550       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
551       "libc++ std::atomic synthetic children",
552       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true);
553 
554   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
555       RegularExpressionSP(new RegularExpression(
556           llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$"))),
557       SyntheticChildrenSP(new ScriptedSyntheticChildren(
558           stl_synth_flags,
559           "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
560 
561   AddCXXSynthetic(
562       cpp_category_sp,
563       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
564       "shared_ptr synthetic children",
565       ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
566       stl_synth_flags, true);
567   AddCXXSynthetic(
568       cpp_category_sp,
569       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
570       "weak_ptr synthetic children",
571       ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
572       stl_synth_flags, true);
573 
574   AddCXXSummary(
575       cpp_category_sp, lldb_private::formatters::LibcxxFunctionSummaryProvider,
576       "libc++ std::function summary provider",
577       ConstString("^std::__[[:alnum:]]+::function<.+>$"), stl_summary_flags,
578       true);
579 
580   stl_summary_flags.SetDontShowChildren(false);
581   stl_summary_flags.SetSkipPointers(false);
582   AddCXXSummary(cpp_category_sp,
583                 lldb_private::formatters::LibcxxContainerSummaryProvider,
584                 "libc++ std::bitset summary provider",
585                 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
586                 stl_summary_flags, true);
587   AddCXXSummary(cpp_category_sp,
588                 lldb_private::formatters::LibcxxContainerSummaryProvider,
589                 "libc++ std::vector summary provider",
590                 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
591                 stl_summary_flags, true);
592   AddCXXSummary(cpp_category_sp,
593                 lldb_private::formatters::LibcxxContainerSummaryProvider,
594                 "libc++ std::list summary provider",
595                 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
596                 stl_summary_flags, true);
597   AddCXXSummary(cpp_category_sp,
598                 lldb_private::formatters::LibcxxContainerSummaryProvider,
599                 "libc++ std::list summary provider",
600                 ConstString("^std::__[[:alnum:]]+::list<.+>(( )?&)?$"),
601                 stl_summary_flags, true);
602   AddCXXSummary(cpp_category_sp,
603                 lldb_private::formatters::LibcxxContainerSummaryProvider,
604                 "libc++ std::map summary provider",
605                 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
606                 stl_summary_flags, true);
607   AddCXXSummary(cpp_category_sp,
608                 lldb_private::formatters::LibcxxContainerSummaryProvider,
609                 "libc++ std::deque summary provider",
610                 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
611                 stl_summary_flags, true);
612   AddCXXSummary(cpp_category_sp,
613                 lldb_private::formatters::LibcxxContainerSummaryProvider,
614                 "libc++ std::queue summary provider",
615                 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
616                 stl_summary_flags, true);
617   AddCXXSummary(cpp_category_sp,
618                 lldb_private::formatters::LibcxxContainerSummaryProvider,
619                 "libc++ std::set summary provider",
620                 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
621                 stl_summary_flags, true);
622   AddCXXSummary(cpp_category_sp,
623                 lldb_private::formatters::LibcxxContainerSummaryProvider,
624                 "libc++ std::multiset summary provider",
625                 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
626                 stl_summary_flags, true);
627   AddCXXSummary(cpp_category_sp,
628                 lldb_private::formatters::LibcxxContainerSummaryProvider,
629                 "libc++ std::multimap summary provider",
630                 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
631                 stl_summary_flags, true);
632   AddCXXSummary(
633       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
634       "libc++ std::unordered containers summary provider",
635       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
636       stl_summary_flags, true);
637   AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
638                 "libc++ std::tuple summary provider",
639                 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
640                 stl_summary_flags, true);
641   AddCXXSummary(
642       cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider,
643       "libc++ std::atomic summary provider",
644       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_summary_flags,
645       true);
646   AddCXXSummary(cpp_category_sp,
647                 lldb_private::formatters::LibcxxOptionalSummaryProvider,
648                 "libc++ std::optional summary provider",
649                 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
650                 stl_summary_flags, true);
651   AddCXXSummary(cpp_category_sp,
652                 lldb_private::formatters::LibcxxVariantSummaryProvider,
653                 "libc++ std::variant summary provider",
654                 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
655                 stl_summary_flags, true);
656 
657   stl_summary_flags.SetSkipPointers(true);
658 
659   AddCXXSummary(cpp_category_sp,
660                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
661                 "libc++ std::shared_ptr summary provider",
662                 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
663                 stl_summary_flags, true);
664   AddCXXSummary(cpp_category_sp,
665                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
666                 "libc++ std::weak_ptr summary provider",
667                 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
668                 stl_summary_flags, true);
669 
670   AddCXXSynthetic(
671       cpp_category_sp,
672       lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
673       "std::vector iterator synthetic children",
674       ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
675       true);
676 
677   AddCXXSynthetic(
678       cpp_category_sp,
679       lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
680       "std::map iterator synthetic children",
681       ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags,
682       true);
683 #endif
684 }
685 
686 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
687   if (!cpp_category_sp)
688     return;
689 
690   TypeSummaryImpl::Flags stl_summary_flags;
691   stl_summary_flags.SetCascades(true)
692       .SetSkipPointers(false)
693       .SetSkipReferences(false)
694       .SetDontShowChildren(true)
695       .SetDontShowValue(true)
696       .SetShowMembersOneLiner(false)
697       .SetHideItemNames(false);
698 
699   lldb::TypeSummaryImplSP std_string_summary_sp(
700       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
701 
702   lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
703       stl_summary_flags, LibStdcppStringSummaryProvider,
704       "libstdc++ c++11 std::string summary provider"));
705   lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
706       stl_summary_flags, LibStdcppWStringSummaryProvider,
707       "libstdc++ c++11 std::wstring summary provider"));
708 
709   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
710                                                     std_string_summary_sp);
711   cpp_category_sp->GetTypeSummariesContainer()->Add(
712       ConstString("std::basic_string<char>"), std_string_summary_sp);
713   cpp_category_sp->GetTypeSummariesContainer()->Add(
714       ConstString("std::basic_string<char,std::char_traits<char>,std::"
715                   "allocator<char> >"),
716       std_string_summary_sp);
717   cpp_category_sp->GetTypeSummariesContainer()->Add(
718       ConstString("std::basic_string<char, std::char_traits<char>, "
719                   "std::allocator<char> >"),
720       std_string_summary_sp);
721 
722   cpp_category_sp->GetTypeSummariesContainer()->Add(
723       ConstString("std::__cxx11::string"), cxx11_string_summary_sp);
724   cpp_category_sp->GetTypeSummariesContainer()->Add(
725       ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, "
726                   "std::allocator<char> >"),
727       cxx11_string_summary_sp);
728 
729   // making sure we force-pick the summary for printing wstring (_M_p is a
730   // wchar_t*)
731   lldb::TypeSummaryImplSP std_wstring_summary_sp(
732       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
733 
734   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
735                                                     std_wstring_summary_sp);
736   cpp_category_sp->GetTypeSummariesContainer()->Add(
737       ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp);
738   cpp_category_sp->GetTypeSummariesContainer()->Add(
739       ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::"
740                   "allocator<wchar_t> >"),
741       std_wstring_summary_sp);
742   cpp_category_sp->GetTypeSummariesContainer()->Add(
743       ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, "
744                   "std::allocator<wchar_t> >"),
745       std_wstring_summary_sp);
746 
747   cpp_category_sp->GetTypeSummariesContainer()->Add(
748       ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp);
749   cpp_category_sp->GetTypeSummariesContainer()->Add(
750       ConstString("std::__cxx11::basic_string<wchar_t, "
751                   "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
752       cxx11_wstring_summary_sp);
753 
754 #ifndef LLDB_DISABLE_PYTHON
755 
756   SyntheticChildren::Flags stl_synth_flags;
757   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
758       false);
759 
760   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
761       RegularExpressionSP(
762           new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))),
763       SyntheticChildrenSP(new ScriptedSyntheticChildren(
764           stl_synth_flags,
765           "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
766   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
767       RegularExpressionSP(
768           new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))),
769       SyntheticChildrenSP(new ScriptedSyntheticChildren(
770           stl_synth_flags,
771           "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
772   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
773       RegularExpressionSP(new RegularExpression(
774           llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$"))),
775       SyntheticChildrenSP(new ScriptedSyntheticChildren(
776           stl_synth_flags,
777           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
778   stl_summary_flags.SetDontShowChildren(false);
779   stl_summary_flags.SetSkipPointers(true);
780   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
781       RegularExpressionSP(
782           new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))),
783       TypeSummaryImplSP(
784           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
785   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
786       RegularExpressionSP(
787           new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))),
788       TypeSummaryImplSP(
789           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
790   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
791       RegularExpressionSP(new RegularExpression(
792           llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$"))),
793       TypeSummaryImplSP(
794           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
795 
796   AddCXXSynthetic(
797       cpp_category_sp,
798       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
799       "std::vector iterator synthetic children",
800       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
801 
802   AddCXXSynthetic(
803       cpp_category_sp,
804       lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
805       "std::map iterator synthetic children",
806       ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
807 
808   AddCXXSynthetic(
809       cpp_category_sp,
810       lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
811       "std::unique_ptr synthetic children",
812       ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
813   AddCXXSynthetic(
814       cpp_category_sp,
815       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
816       "std::shared_ptr synthetic children",
817       ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
818   AddCXXSynthetic(
819       cpp_category_sp,
820       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
821       "std::weak_ptr synthetic children",
822       ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
823   AddCXXSynthetic(
824       cpp_category_sp,
825       lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
826       "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"),
827       stl_synth_flags, true);
828 
829   AddCXXSummary(cpp_category_sp,
830                 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
831                 "libstdc++ std::unique_ptr summary provider",
832                 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
833                 true);
834   AddCXXSummary(cpp_category_sp,
835                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
836                 "libstdc++ std::shared_ptr summary provider",
837                 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
838                 true);
839   AddCXXSummary(cpp_category_sp,
840                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
841                 "libstdc++ std::weak_ptr summary provider",
842                 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
843                 true);
844 #endif
845 }
846 
847 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
848   if (!cpp_category_sp)
849     return;
850 
851   TypeSummaryImpl::Flags string_flags;
852   string_flags.SetCascades(true)
853       .SetSkipPointers(true)
854       .SetSkipReferences(false)
855       .SetDontShowChildren(true)
856       .SetDontShowValue(false)
857       .SetShowMembersOneLiner(false)
858       .SetHideItemNames(false);
859 
860   TypeSummaryImpl::Flags string_array_flags;
861   string_array_flags.SetCascades(true)
862       .SetSkipPointers(true)
863       .SetSkipReferences(false)
864       .SetDontShowChildren(true)
865       .SetDontShowValue(true)
866       .SetShowMembersOneLiner(false)
867       .SetHideItemNames(false);
868 
869 #ifndef LLDB_DISABLE_PYTHON
870   // FIXME because of a bug in the FormattersContainer we need to add a summary
871   // for both X* and const X* (<rdar://problem/12717717>)
872   AddCXXSummary(
873       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
874       "char16_t * summary provider", ConstString("char16_t *"), string_flags);
875   AddCXXSummary(cpp_category_sp,
876                 lldb_private::formatters::Char16StringSummaryProvider,
877                 "char16_t [] summary provider",
878                 ConstString("char16_t \\[[0-9]+\\]"), string_array_flags, true);
879 
880   AddCXXSummary(
881       cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider,
882       "char32_t * summary provider", ConstString("char32_t *"), string_flags);
883   AddCXXSummary(cpp_category_sp,
884                 lldb_private::formatters::Char32StringSummaryProvider,
885                 "char32_t [] summary provider",
886                 ConstString("char32_t \\[[0-9]+\\]"), string_array_flags, true);
887 
888   AddCXXSummary(
889       cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider,
890       "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
891   AddCXXSummary(cpp_category_sp,
892                 lldb_private::formatters::WCharStringSummaryProvider,
893                 "wchar_t * summary provider",
894                 ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
895 
896   AddCXXSummary(
897       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
898       "unichar * summary provider", ConstString("unichar *"), string_flags);
899 
900   TypeSummaryImpl::Flags widechar_flags;
901   widechar_flags.SetDontShowValue(true)
902       .SetSkipPointers(true)
903       .SetSkipReferences(false)
904       .SetCascades(true)
905       .SetDontShowChildren(true)
906       .SetHideItemNames(true)
907       .SetShowMembersOneLiner(false);
908 
909   AddCXXSummary(
910       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
911       "char16_t summary provider", ConstString("char16_t"), widechar_flags);
912   AddCXXSummary(
913       cpp_category_sp, lldb_private::formatters::Char32SummaryProvider,
914       "char32_t summary provider", ConstString("char32_t"), widechar_flags);
915   AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider,
916                 "wchar_t summary provider", ConstString("wchar_t"),
917                 widechar_flags);
918 
919   AddCXXSummary(
920       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
921       "unichar summary provider", ConstString("unichar"), widechar_flags);
922 #endif
923 }
924 
925 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
926   class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
927   public:
928     virtual CompilerType AdjustForInclusion(CompilerType &candidate) override {
929       LanguageType lang_type(candidate.GetMinimumLanguage());
930       if (!Language::LanguageIsC(lang_type) &&
931           !Language::LanguageIsCPlusPlus(lang_type))
932         return CompilerType();
933       if (candidate.IsTypedefType())
934         return candidate.GetTypedefedType();
935       return candidate;
936     }
937   };
938 
939   return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger());
940 }
941 
942 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
943   static llvm::once_flag g_initialize;
944   static TypeCategoryImplSP g_category;
945 
946   llvm::call_once(g_initialize, [this]() -> void {
947     DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
948     if (g_category) {
949       LoadLibStdcppFormatters(g_category);
950       LoadLibCxxFormatters(g_category);
951       LoadSystemFormatters(g_category);
952     }
953   });
954   return g_category;
955 }
956 
957 HardcodedFormatters::HardcodedSummaryFinder
958 CPlusPlusLanguage::GetHardcodedSummaries() {
959   static llvm::once_flag g_initialize;
960   static ConstString g_vectortypes("VectorTypes");
961   static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
962 
963   llvm::call_once(g_initialize, []() -> void {
964     g_formatters.push_back(
965         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
966            FormatManager &) -> TypeSummaryImpl::SharedPointer {
967           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
968               new CXXFunctionSummaryFormat(
969                   TypeSummaryImpl::Flags(),
970                   lldb_private::formatters::CXXFunctionPointerSummaryProvider,
971                   "Function pointer summary provider"));
972           if (valobj.GetCompilerType().IsFunctionPointerType()) {
973             return formatter_sp;
974           }
975           return nullptr;
976         });
977     g_formatters.push_back(
978         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
979            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
980           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
981               new CXXFunctionSummaryFormat(
982                   TypeSummaryImpl::Flags()
983                       .SetCascades(true)
984                       .SetDontShowChildren(true)
985                       .SetHideItemNames(true)
986                       .SetShowMembersOneLiner(true)
987                       .SetSkipPointers(true)
988                       .SetSkipReferences(false),
989                   lldb_private::formatters::VectorTypeSummaryProvider,
990                   "vector_type pointer summary provider"));
991           if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) {
992             if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
993               return formatter_sp;
994           }
995           return nullptr;
996         });
997     g_formatters.push_back(
998         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
999            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1000           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1001               new CXXFunctionSummaryFormat(
1002                   TypeSummaryImpl::Flags()
1003                       .SetCascades(true)
1004                       .SetDontShowChildren(true)
1005                       .SetHideItemNames(true)
1006                       .SetShowMembersOneLiner(true)
1007                       .SetSkipPointers(true)
1008                       .SetSkipReferences(false),
1009                   lldb_private::formatters::BlockPointerSummaryProvider,
1010                   "block pointer summary provider"));
1011           if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) {
1012             return formatter_sp;
1013           }
1014           return nullptr;
1015         });
1016   });
1017 
1018   return g_formatters;
1019 }
1020 
1021 HardcodedFormatters::HardcodedSyntheticFinder
1022 CPlusPlusLanguage::GetHardcodedSynthetics() {
1023   static llvm::once_flag g_initialize;
1024   static ConstString g_vectortypes("VectorTypes");
1025   static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
1026 
1027   llvm::call_once(g_initialize, []() -> void {
1028     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1029                               lldb::DynamicValueType,
1030                               FormatManager &
1031                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
1032       static CXXSyntheticChildren::SharedPointer formatter_sp(
1033           new CXXSyntheticChildren(
1034               SyntheticChildren::Flags()
1035                   .SetCascades(true)
1036                   .SetSkipPointers(true)
1037                   .SetSkipReferences(true)
1038                   .SetNonCacheable(true),
1039               "vector_type synthetic children",
1040               lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
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([](lldb_private::ValueObject &valobj,
1048                               lldb::DynamicValueType,
1049                               FormatManager &
1050                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
1051       static CXXSyntheticChildren::SharedPointer formatter_sp(
1052           new CXXSyntheticChildren(
1053               SyntheticChildren::Flags()
1054                   .SetCascades(true)
1055                   .SetSkipPointers(true)
1056                   .SetSkipReferences(true)
1057                   .SetNonCacheable(true),
1058               "block pointer synthetic children",
1059               lldb_private::formatters::BlockPointerSyntheticFrontEndCreator));
1060       if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) {
1061         return formatter_sp;
1062       }
1063       return nullptr;
1064     });
1065 
1066   });
1067 
1068   return g_formatters;
1069 }
1070 
1071 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
1072   const auto suffixes = {".cpp", ".cxx", ".c++", ".cc",  ".c",
1073                          ".h",   ".hh",  ".hpp", ".hxx", ".h++"};
1074   for (auto suffix : suffixes) {
1075     if (file_path.endswith_lower(suffix))
1076       return true;
1077   }
1078 
1079   // Check if we're in a STL path (where the files usually have no extension
1080   // that we could check for.
1081   return file_path.contains("/usr/include/c++/");
1082 }
1083