xref: /llvm-project/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp (revision f6a84ed30b2839a67ffdbf3771d4610d305669d5) 
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   AddCXXSummary(cpp_category_sp,
422                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
423                 "std::string summary provider",
424                 ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags,
425                 true);
426   AddCXXSummary(cpp_category_sp,
427                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
428                 "std::string summary provider",
429                 ConstString("^std::__[[:alnum:]]+::basic_string<char, "
430                             "std::__[[:alnum:]]+::char_traits<char>, "
431                             "std::__[[:alnum:]]+::allocator<char> >$"),
432                 stl_summary_flags, true);
433 
434   AddCXXSummary(cpp_category_sp,
435                 lldb_private::formatters::LibcxxStringSummaryProviderUTF16,
436                 "std::u16string summary provider",
437                 ConstString(
438                     "^std::__[[:alnum:]]+::basic_string<char16_t, "
439                     "std::__[[:alnum:]]+::char_traits<char16_t>, "
440                     "std::__[[:alnum:]]+::allocator<char16_t> >$"),
441                 stl_summary_flags, true);
442 
443   AddCXXSummary(cpp_category_sp,
444                 lldb_private::formatters::LibcxxStringSummaryProviderUTF32,
445                 "std::u32string summary provider",
446                 ConstString(
447                     "^std::__[[:alnum:]]+::basic_string<char32_t, "
448                     "std::__[[:alnum:]]+::char_traits<char32_t>, "
449                     "std::__[[:alnum:]]+::allocator<char32_t> >$"),
450                 stl_summary_flags, true);
451 
452   AddCXXSummary(cpp_category_sp,
453                 lldb_private::formatters::LibcxxWStringSummaryProvider,
454                 "std::wstring summary provider",
455                 ConstString("^std::__[[:alnum:]]+::wstring$"),
456                 stl_summary_flags, true);
457   AddCXXSummary(cpp_category_sp,
458                 lldb_private::formatters::LibcxxWStringSummaryProvider,
459                 "std::wstring summary provider",
460                 ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, "
461                             "std::__[[:alnum:]]+::char_traits<wchar_t>, "
462                             "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
463                 stl_summary_flags, true);
464 
465   SyntheticChildren::Flags stl_synth_flags;
466   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
467       false);
468   SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
469   stl_deref_flags.SetFrontEndWantsDereference();
470 
471   AddCXXSynthetic(
472       cpp_category_sp,
473       lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
474       "libc++ std::bitset synthetic children",
475       ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
476       true);
477   AddCXXSynthetic(
478       cpp_category_sp,
479       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
480       "libc++ std::vector synthetic children",
481       ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
482       true);
483   AddCXXSynthetic(
484       cpp_category_sp,
485       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
486       "libc++ std::forward_list synthetic children",
487       ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
488       stl_synth_flags, true);
489   AddCXXSynthetic(
490       cpp_category_sp,
491       lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
492       "libc++ std::list synthetic children",
493       ConstString("^std::__[[:alnum:]]+::list<.+>(( )?&)?$"), stl_synth_flags,
494       true);
495   AddCXXSynthetic(
496       cpp_category_sp,
497       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
498       "libc++ std::map synthetic children",
499       ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
500       true);
501   AddCXXSynthetic(
502       cpp_category_sp,
503       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
504       "libc++ std::set synthetic children",
505       ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
506       true);
507   AddCXXSynthetic(
508       cpp_category_sp,
509       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
510       "libc++ std::multiset synthetic children",
511       ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
512       stl_deref_flags, true);
513   AddCXXSynthetic(
514       cpp_category_sp,
515       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
516       "libc++ std::multimap synthetic children",
517       ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
518       stl_synth_flags, true);
519   AddCXXSynthetic(
520       cpp_category_sp,
521       lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator,
522       "libc++ std::unordered containers synthetic children",
523       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
524       stl_synth_flags, true);
525   AddCXXSynthetic(
526       cpp_category_sp,
527       lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
528       "libc++ std::initializer_list synthetic children",
529       ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
530       true);
531   AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator,
532                   "libc++ std::queue synthetic children",
533                   ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
534                   stl_synth_flags, true);
535   AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
536                   "libc++ std::tuple synthetic children",
537                   ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
538                   stl_synth_flags, true);
539   AddCXXSynthetic(cpp_category_sp, LibcxxOptionalFrontEndCreator,
540                   "libc++ std::optional synthetic children",
541                   ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
542                   stl_synth_flags, true);
543   AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
544                   "libc++ std::variant synthetic children",
545                   ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
546                   stl_synth_flags, true);
547   AddCXXSynthetic(
548       cpp_category_sp,
549       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
550       "libc++ std::atomic synthetic children",
551       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true);
552 
553   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
554       RegularExpressionSP(new RegularExpression(
555           llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$"))),
556       SyntheticChildrenSP(new ScriptedSyntheticChildren(
557           stl_synth_flags,
558           "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
559 
560   AddCXXSynthetic(
561       cpp_category_sp,
562       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
563       "shared_ptr synthetic children",
564       ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
565       stl_synth_flags, true);
566   AddCXXSynthetic(
567       cpp_category_sp,
568       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
569       "weak_ptr synthetic children",
570       ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
571       stl_synth_flags, true);
572 
573   AddCXXSummary(
574       cpp_category_sp, lldb_private::formatters::LibcxxFunctionSummaryProvider,
575       "libc++ std::function summary provider",
576       ConstString("^std::__[[:alnum:]]+::function<.+>$"), stl_summary_flags,
577       true);
578 
579   stl_summary_flags.SetDontShowChildren(false);
580   stl_summary_flags.SetSkipPointers(false);
581   AddCXXSummary(cpp_category_sp,
582                 lldb_private::formatters::LibcxxContainerSummaryProvider,
583                 "libc++ std::bitset summary provider",
584                 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
585                 stl_summary_flags, true);
586   AddCXXSummary(cpp_category_sp,
587                 lldb_private::formatters::LibcxxContainerSummaryProvider,
588                 "libc++ std::vector summary provider",
589                 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
590                 stl_summary_flags, true);
591   AddCXXSummary(cpp_category_sp,
592                 lldb_private::formatters::LibcxxContainerSummaryProvider,
593                 "libc++ std::list summary provider",
594                 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
595                 stl_summary_flags, true);
596   AddCXXSummary(cpp_category_sp,
597                 lldb_private::formatters::LibcxxContainerSummaryProvider,
598                 "libc++ std::list summary provider",
599                 ConstString("^std::__[[:alnum:]]+::list<.+>(( )?&)?$"),
600                 stl_summary_flags, true);
601   AddCXXSummary(cpp_category_sp,
602                 lldb_private::formatters::LibcxxContainerSummaryProvider,
603                 "libc++ std::map summary provider",
604                 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
605                 stl_summary_flags, true);
606   AddCXXSummary(cpp_category_sp,
607                 lldb_private::formatters::LibcxxContainerSummaryProvider,
608                 "libc++ std::deque summary provider",
609                 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
610                 stl_summary_flags, true);
611   AddCXXSummary(cpp_category_sp,
612                 lldb_private::formatters::LibcxxContainerSummaryProvider,
613                 "libc++ std::queue summary provider",
614                 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
615                 stl_summary_flags, true);
616   AddCXXSummary(cpp_category_sp,
617                 lldb_private::formatters::LibcxxContainerSummaryProvider,
618                 "libc++ std::set summary provider",
619                 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
620                 stl_summary_flags, true);
621   AddCXXSummary(cpp_category_sp,
622                 lldb_private::formatters::LibcxxContainerSummaryProvider,
623                 "libc++ std::multiset summary provider",
624                 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
625                 stl_summary_flags, true);
626   AddCXXSummary(cpp_category_sp,
627                 lldb_private::formatters::LibcxxContainerSummaryProvider,
628                 "libc++ std::multimap summary provider",
629                 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
630                 stl_summary_flags, true);
631   AddCXXSummary(
632       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
633       "libc++ std::unordered containers summary provider",
634       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
635       stl_summary_flags, true);
636   AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
637                 "libc++ std::tuple summary provider",
638                 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
639                 stl_summary_flags, true);
640   AddCXXSummary(
641       cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider,
642       "libc++ std::atomic summary provider",
643       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_summary_flags,
644       true);
645   AddCXXSummary(cpp_category_sp,
646                 lldb_private::formatters::LibcxxOptionalSummaryProvider,
647                 "libc++ std::optional summary provider",
648                 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
649                 stl_summary_flags, true);
650   AddCXXSummary(cpp_category_sp,
651                 lldb_private::formatters::LibcxxVariantSummaryProvider,
652                 "libc++ std::variant summary provider",
653                 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
654                 stl_summary_flags, true);
655 
656   stl_summary_flags.SetSkipPointers(true);
657 
658   AddCXXSummary(cpp_category_sp,
659                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
660                 "libc++ std::shared_ptr summary provider",
661                 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
662                 stl_summary_flags, true);
663   AddCXXSummary(cpp_category_sp,
664                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
665                 "libc++ std::weak_ptr summary provider",
666                 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
667                 stl_summary_flags, true);
668 
669   AddCXXSynthetic(
670       cpp_category_sp,
671       lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
672       "std::vector iterator synthetic children",
673       ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
674       true);
675 
676   AddCXXSynthetic(
677       cpp_category_sp,
678       lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
679       "std::map iterator synthetic children",
680       ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags,
681       true);
682 }
683 
684 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
685   if (!cpp_category_sp)
686     return;
687 
688   TypeSummaryImpl::Flags stl_summary_flags;
689   stl_summary_flags.SetCascades(true)
690       .SetSkipPointers(false)
691       .SetSkipReferences(false)
692       .SetDontShowChildren(true)
693       .SetDontShowValue(true)
694       .SetShowMembersOneLiner(false)
695       .SetHideItemNames(false);
696 
697   lldb::TypeSummaryImplSP std_string_summary_sp(
698       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
699 
700   lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
701       stl_summary_flags, LibStdcppStringSummaryProvider,
702       "libstdc++ c++11 std::string summary provider"));
703   lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
704       stl_summary_flags, LibStdcppWStringSummaryProvider,
705       "libstdc++ c++11 std::wstring summary provider"));
706 
707   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
708                                                     std_string_summary_sp);
709   cpp_category_sp->GetTypeSummariesContainer()->Add(
710       ConstString("std::basic_string<char>"), std_string_summary_sp);
711   cpp_category_sp->GetTypeSummariesContainer()->Add(
712       ConstString("std::basic_string<char,std::char_traits<char>,std::"
713                   "allocator<char> >"),
714       std_string_summary_sp);
715   cpp_category_sp->GetTypeSummariesContainer()->Add(
716       ConstString("std::basic_string<char, std::char_traits<char>, "
717                   "std::allocator<char> >"),
718       std_string_summary_sp);
719 
720   cpp_category_sp->GetTypeSummariesContainer()->Add(
721       ConstString("std::__cxx11::string"), cxx11_string_summary_sp);
722   cpp_category_sp->GetTypeSummariesContainer()->Add(
723       ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, "
724                   "std::allocator<char> >"),
725       cxx11_string_summary_sp);
726 
727   // making sure we force-pick the summary for printing wstring (_M_p is a
728   // wchar_t*)
729   lldb::TypeSummaryImplSP std_wstring_summary_sp(
730       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
731 
732   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
733                                                     std_wstring_summary_sp);
734   cpp_category_sp->GetTypeSummariesContainer()->Add(
735       ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp);
736   cpp_category_sp->GetTypeSummariesContainer()->Add(
737       ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::"
738                   "allocator<wchar_t> >"),
739       std_wstring_summary_sp);
740   cpp_category_sp->GetTypeSummariesContainer()->Add(
741       ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, "
742                   "std::allocator<wchar_t> >"),
743       std_wstring_summary_sp);
744 
745   cpp_category_sp->GetTypeSummariesContainer()->Add(
746       ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp);
747   cpp_category_sp->GetTypeSummariesContainer()->Add(
748       ConstString("std::__cxx11::basic_string<wchar_t, "
749                   "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
750       cxx11_wstring_summary_sp);
751 
752   SyntheticChildren::Flags stl_synth_flags;
753   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
754       false);
755 
756   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
757       RegularExpressionSP(
758           new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))),
759       SyntheticChildrenSP(new ScriptedSyntheticChildren(
760           stl_synth_flags,
761           "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
762   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
763       RegularExpressionSP(
764           new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))),
765       SyntheticChildrenSP(new ScriptedSyntheticChildren(
766           stl_synth_flags,
767           "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
768   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
769       RegularExpressionSP(new RegularExpression(
770           llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$"))),
771       SyntheticChildrenSP(new ScriptedSyntheticChildren(
772           stl_synth_flags,
773           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
774   stl_summary_flags.SetDontShowChildren(false);
775   stl_summary_flags.SetSkipPointers(true);
776   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
777       RegularExpressionSP(
778           new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))),
779       TypeSummaryImplSP(
780           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
781   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
782       RegularExpressionSP(
783           new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))),
784       TypeSummaryImplSP(
785           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
786   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
787       RegularExpressionSP(new RegularExpression(
788           llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$"))),
789       TypeSummaryImplSP(
790           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
791 
792   AddCXXSynthetic(
793       cpp_category_sp,
794       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
795       "std::vector iterator synthetic children",
796       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
797 
798   AddCXXSynthetic(
799       cpp_category_sp,
800       lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
801       "std::map iterator synthetic children",
802       ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
803 
804   AddCXXSynthetic(
805       cpp_category_sp,
806       lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
807       "std::unique_ptr synthetic children",
808       ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
809   AddCXXSynthetic(
810       cpp_category_sp,
811       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
812       "std::shared_ptr synthetic children",
813       ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
814   AddCXXSynthetic(
815       cpp_category_sp,
816       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
817       "std::weak_ptr synthetic children",
818       ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
819   AddCXXSynthetic(
820       cpp_category_sp,
821       lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
822       "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"),
823       stl_synth_flags, true);
824 
825   AddCXXSummary(cpp_category_sp,
826                 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
827                 "libstdc++ std::unique_ptr summary provider",
828                 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
829                 true);
830   AddCXXSummary(cpp_category_sp,
831                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
832                 "libstdc++ std::shared_ptr summary provider",
833                 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
834                 true);
835   AddCXXSummary(cpp_category_sp,
836                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
837                 "libstdc++ std::weak_ptr summary provider",
838                 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
839                 true);
840 }
841 
842 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
843   if (!cpp_category_sp)
844     return;
845 
846   TypeSummaryImpl::Flags string_flags;
847   string_flags.SetCascades(true)
848       .SetSkipPointers(true)
849       .SetSkipReferences(false)
850       .SetDontShowChildren(true)
851       .SetDontShowValue(false)
852       .SetShowMembersOneLiner(false)
853       .SetHideItemNames(false);
854 
855   TypeSummaryImpl::Flags string_array_flags;
856   string_array_flags.SetCascades(true)
857       .SetSkipPointers(true)
858       .SetSkipReferences(false)
859       .SetDontShowChildren(true)
860       .SetDontShowValue(true)
861       .SetShowMembersOneLiner(false)
862       .SetHideItemNames(false);
863 
864   // FIXME because of a bug in the FormattersContainer we need to add a summary
865   // for both X* and const X* (<rdar://problem/12717717>)
866   AddCXXSummary(
867       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
868       "char16_t * summary provider", ConstString("char16_t *"), string_flags);
869   AddCXXSummary(cpp_category_sp,
870                 lldb_private::formatters::Char16StringSummaryProvider,
871                 "char16_t [] summary provider",
872                 ConstString("char16_t \\[[0-9]+\\]"), string_array_flags, true);
873 
874   AddCXXSummary(
875       cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider,
876       "char32_t * summary provider", ConstString("char32_t *"), string_flags);
877   AddCXXSummary(cpp_category_sp,
878                 lldb_private::formatters::Char32StringSummaryProvider,
879                 "char32_t [] summary provider",
880                 ConstString("char32_t \\[[0-9]+\\]"), string_array_flags, true);
881 
882   AddCXXSummary(
883       cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider,
884       "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
885   AddCXXSummary(cpp_category_sp,
886                 lldb_private::formatters::WCharStringSummaryProvider,
887                 "wchar_t * summary provider",
888                 ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
889 
890   AddCXXSummary(
891       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
892       "unichar * summary provider", ConstString("unichar *"), string_flags);
893 
894   TypeSummaryImpl::Flags widechar_flags;
895   widechar_flags.SetDontShowValue(true)
896       .SetSkipPointers(true)
897       .SetSkipReferences(false)
898       .SetCascades(true)
899       .SetDontShowChildren(true)
900       .SetHideItemNames(true)
901       .SetShowMembersOneLiner(false);
902 
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     virtual 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