19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Demangle/ItaniumDemangle.h"
53 PluginManager::RegisterPlugin(GetPluginNameStatic(),
"C++ Language",
57 void CPlusPlusLanguage::Terminate() {
58 PluginManager::UnregisterPlugin(CreateInstance);
61 bool CPlusPlusLanguage::SymbolNameFitsToLanguage(Mangled mangled)
const {
62 const char *mangled_name = mangled.GetMangledName().GetCString();
63 return mangled_name && CPlusPlusLanguage::IsCPPMangledName(mangled_name);
66 ConstString CPlusPlusLanguage::GetDemangledFunctionNameWithoutArguments(
67 Mangled mangled)
const {
68 const char *mangled_name_cstr = mangled.GetMangledName().
GetCString();
69 ConstString demangled_name = mangled.GetDemangledName();
70 if (demangled_name && mangled_name_cstr && mangled_name_cstr[0]) {
71 if (mangled_name_cstr[0] ==
'_' && mangled_name_cstr[1] ==
'Z' &&
72 (mangled_name_cstr[2] !=
'T' &&
75 mangled_name_cstr[2] !=
'G' &&
76 mangled_name_cstr[2] !=
'Z'))
84 shortname = cxx_method.
GetContext().str() +
"::";
91 return demangled_name;
92 return mangled.GetMangledName();
99 if (Language::LanguageIsCPlusPlus(language) &&
105 void CPlusPlusLanguage::MethodName::Clear() {
107 m_basename = llvm::StringRef();
108 m_context = llvm::StringRef();
109 m_arguments = llvm::StringRef();
110 m_qualifiers = llvm::StringRef();
112 m_parse_error =
false;
116 const llvm::StringRef &left_right_chars,
117 size_t &left_pos,
size_t &right_pos,
118 size_t pos = llvm::StringRef::npos) {
119 assert(left_right_chars.size() == 2);
120 left_pos = llvm::StringRef::npos;
121 const char left_char = left_right_chars[0];
122 const char right_char = left_right_chars[1];
123 pos = s.find_last_of(left_right_chars, pos);
124 if (pos == llvm::StringRef::npos || s[pos] == left_char)
128 while (pos > 0 && depth > 0) {
129 pos = s.find_last_of(left_right_chars, pos);
130 if (pos == llvm::StringRef::npos)
132 if (s[pos] == left_char) {
135 return left_pos < right_pos;
137 }
else if (s[pos] == right_char) {
150 if (basename.size() > 0 && basename[0] ==
'~')
153 if (basename.size() <= idx)
156 if (!std::isalpha(basename[idx]) && basename[idx] !=
'_')
162 while (idx < basename.size()) {
163 if (!std::isalnum(basename[idx]) && basename[idx] !=
'_')
169 return idx == basename.size();
172 bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
177 size_t arg_start, arg_end;
178 llvm::StringRef full(m_full.GetCString());
179 llvm::StringRef parens(
"()", 2);
181 m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
182 if (arg_end + 1 < full.size())
183 m_qualifiers = full.substr(arg_end + 1).ltrim();
187 size_t basename_end = arg_start;
188 size_t context_start = 0;
189 size_t context_end = full.rfind(
':', basename_end);
190 if (context_end == llvm::StringRef::npos)
191 m_basename = full.substr(0, basename_end);
193 if (context_start < context_end)
194 m_context = full.substr(context_start, context_end - 1 - context_start);
195 const size_t basename_begin = context_end + 1;
196 m_basename = full.substr(basename_begin, basename_end - basename_begin);
204 m_context = llvm::StringRef();
205 m_basename = llvm::StringRef();
206 m_arguments = llvm::StringRef();
207 m_qualifiers = llvm::StringRef();
214 void CPlusPlusLanguage::MethodName::Parse() {
215 if (!m_parsed && m_full) {
216 if (TrySimplifiedParse()) {
217 m_parse_error =
false;
221 m_basename =
function.getValue().name.basename;
222 m_context =
function.getValue().name.context;
223 m_arguments =
function.getValue().arguments;
224 m_qualifiers =
function.getValue().qualifiers;
225 m_parse_error =
false;
227 m_parse_error =
true;
234 llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() {
240 llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() {
246 llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() {
252 llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() {
258 std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
261 if (m_context.empty())
271 bool CPlusPlusLanguage::MethodName::ContainsPath(llvm::StringRef path) {
276 return m_full.GetStringRef().contains(path);
278 llvm::StringRef identifier;
279 llvm::StringRef context;
282 = CPlusPlusLanguage::ExtractContextAndIdentifier(path_str.c_str(),
286 return m_full.GetStringRef().contains(path);
288 if (identifier != GetBasename())
294 if (m_context.empty())
297 llvm::StringRef haystack = m_context;
298 if (!haystack.consume_back(context))
300 if (haystack.empty() || !isalnum(haystack.back()))
306 bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
310 Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
312 if (scheme == Mangled::eManglingSchemeNone)
318 bool CPlusPlusLanguage::DemangledNameContainsPath(llvm::StringRef path,
324 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
325 const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
332 identifier = full_name.getValue().basename;
333 context = full_name.getValue().context;
340 class NodeAllocator {
341 llvm::BumpPtrAllocator Alloc;
344 void reset() { Alloc.Reset(); }
346 template <
typename T,
typename...
Args> T *makeNode(
Args &&... args) {
347 return new (Alloc.Allocate(
sizeof(T),
alignof(T)))
348 T(std::forward<Args>(args)...);
351 void *allocateNodeArray(
size_t sz) {
352 return Alloc.Allocate(
sizeof(llvm::itanium_demangle::Node *) * sz,
353 alignof(llvm::itanium_demangle::Node *));
357 template <
typename Derived>
358 class ManglingSubstitutor
359 :
public llvm::itanium_demangle::AbstractManglingParser<Derived,
362 llvm::itanium_demangle::AbstractManglingParser<Derived, NodeAllocator>;
365 ManglingSubstitutor() :
Base(nullptr, nullptr) {}
367 template <
typename... Ts>
368 ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) {
369 this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...);
370 return substituteImpl(Mangled);
374 void reset(llvm::StringRef Mangled) {
375 Base::reset(Mangled.begin(), Mangled.end());
376 Written = Mangled.begin();
381 ConstString substituteImpl(llvm::StringRef Mangled) {
383 if (this->parse() ==
nullptr) {
384 LLDB_LOG(log,
"Failed to substitute mangling in {0}", Mangled);
391 appendUnchangedInput();
392 LLDB_LOG(log,
"Substituted mangling {0} -> {1}", Mangled, Result);
396 void trySubstitute(llvm::StringRef From, llvm::StringRef To) {
397 if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From))
401 appendUnchangedInput();
405 Written += From.size();
414 llvm::SmallString<128> Result;
419 const char *currentParserPos()
const {
return this->First; }
421 void appendUnchangedInput() {
423 llvm::StringRef(Written, std::distance(Written, currentParserPos()));
424 Written = currentParserPos();
430 class TypeSubstitutor :
public ManglingSubstitutor<TypeSubstitutor> {
431 llvm::StringRef Search;
432 llvm::StringRef Replace;
435 void reset(llvm::StringRef Mangled, llvm::StringRef Search,
436 llvm::StringRef Replace) {
437 ManglingSubstitutor::reset(Mangled);
438 this->Search = Search;
439 this->Replace = Replace;
442 llvm::itanium_demangle::Node *parseType() {
443 trySubstitute(Search, Replace);
444 return ManglingSubstitutor::parseType();
448 class CtorDtorSubstitutor :
public ManglingSubstitutor<CtorDtorSubstitutor> {
450 llvm::itanium_demangle::Node *
451 parseCtorDtorName(llvm::itanium_demangle::Node *&SoFar, NameState *State) {
452 trySubstitute(
"C1",
"C2");
453 trySubstitute(
"D1",
"D2");
454 return ManglingSubstitutor::parseCtorDtorName(SoFar, State);
459 std::vector<ConstString> CPlusPlusLanguage::GenerateAlternateFunctionManglings(
461 std::vector<ConstString> alternates;
471 if (!strncmp(mangled_name.
GetCString(),
"_ZN", 3) &&
472 strncmp(mangled_name.
GetCString(),
"_ZNK", 4)) {
474 fixed_scratch.append(mangled_name.
GetCString() + 3);
479 if (!strncmp(mangled_name.
GetCString(),
"_Z", 2) &&
480 strncmp(mangled_name.
GetCString(),
"_ZL", 3)) {
482 fixed_scratch.append(mangled_name.
GetCString() + 2);
493 alternates.push_back(char_fixup);
498 alternates.push_back(long_fixup);
504 alternates.push_back(ulong_fixup);
507 CtorDtorSubstitutor().substitute(mangled_name.
GetStringRef()))
508 alternates.push_back(ctor_fixup);
513 ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
515 ConstString demangled = mangled.GetDemangledName();
522 if (!scope_qualified_name.size())
532 std::vector<ConstString> alternates;
535 std::vector<ConstString> param_and_qual_matches;
536 std::vector<ConstString> param_matches;
537 for (
size_t i = 0; i < alternates.size(); i++) {
538 ConstString alternate_mangled_name = alternates[i];
539 Mangled mangled(alternate_mangled_name);
540 ConstString demangled = mangled.GetDemangledName();
548 param_and_qual_matches.push_back(alternate_mangled_name);
550 param_matches.push_back(alternate_mangled_name);
554 if (param_and_qual_matches.size())
555 return param_and_qual_matches[0];
557 else if (param_matches.size())
558 return param_matches[0];
564 if (!cpp_category_sp)
578 "std::string summary provider",
579 ConstString(
"^std::__[[:alnum:]]+::string$"), stl_summary_flags,
583 "std::string summary provider",
584 ConstString(
"^std::__[[:alnum:]]+::basic_string<char, "
585 "std::__[[:alnum:]]+::char_traits<char>, "
586 "std::__[[:alnum:]]+::allocator<char> >$"),
587 stl_summary_flags,
true);
590 "std::string summary provider",
591 ConstString(
"^std::__[[:alnum:]]+::basic_string<unsigned char, "
592 "std::__[[:alnum:]]+::char_traits<unsigned char>, "
593 "std::__[[:alnum:]]+::allocator<unsigned char> >$"),
594 stl_summary_flags,
true);
598 "std::u16string summary provider",
599 ConstString(
"^std::__[[:alnum:]]+::basic_string<char16_t, "
600 "std::__[[:alnum:]]+::char_traits<char16_t>, "
601 "std::__[[:alnum:]]+::allocator<char16_t> >$"),
602 stl_summary_flags,
true);
606 "std::u32string summary provider",
607 ConstString(
"^std::__[[:alnum:]]+::basic_string<char32_t, "
608 "std::__[[:alnum:]]+::char_traits<char32_t>, "
609 "std::__[[:alnum:]]+::allocator<char32_t> >$"),
610 stl_summary_flags,
true);
614 "std::wstring summary provider",
615 ConstString(
"^std::__[[:alnum:]]+::wstring$"), stl_summary_flags,
true);
618 "std::wstring summary provider",
619 ConstString(
"^std::__[[:alnum:]]+::basic_string<wchar_t, "
620 "std::__[[:alnum:]]+::char_traits<wchar_t>, "
621 "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
622 stl_summary_flags,
true);
626 "std::string_view summary provider",
628 stl_summary_flags,
true);
631 "std::string_view summary provider",
632 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<char, "
633 "std::__[[:alnum:]]+::char_traits<char> >$"),
634 stl_summary_flags,
true);
638 "std::string_view summary provider",
639 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<unsigned char, "
640 "std::__[[:alnum:]]+::char_traits<unsigned char> >$"),
641 stl_summary_flags,
true);
645 "std::u16string_view summary provider",
646 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<char16_t, "
647 "std::__[[:alnum:]]+::char_traits<char16_t> >$"),
648 stl_summary_flags,
true);
652 "std::u32string_view summary provider",
653 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<char32_t, "
654 "std::__[[:alnum:]]+::char_traits<char32_t> >$"),
655 stl_summary_flags,
true);
659 "std::wstring_view summary provider",
660 ConstString(
"^std::__[[:alnum:]]+::wstring_view$"),
661 stl_summary_flags,
true);
664 "std::wstring_view summary provider",
665 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<wchar_t, "
666 "std::__[[:alnum:]]+::char_traits<wchar_t> >$"),
667 stl_summary_flags,
true);
678 "libc++ std::bitset synthetic children",
679 ConstString(
"^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
684 "libc++ std::vector synthetic children",
685 ConstString(
"^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
690 "libc++ std::forward_list synthetic children",
691 ConstString(
"^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
692 stl_synth_flags,
true);
696 "libc++ std::list synthetic children",
699 ConstString(
"^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
700 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
701 stl_deref_flags,
true);
705 "libc++ std::map synthetic children",
706 ConstString(
"^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
711 "libc++ std::set synthetic children",
712 ConstString(
"^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
717 "libc++ std::multiset synthetic children",
718 ConstString(
"^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
719 stl_deref_flags,
true);
723 "libc++ std::multimap synthetic children",
724 ConstString(
"^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
725 stl_synth_flags,
true);
729 "libc++ std::unordered containers synthetic children",
730 ConstString(
"^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
731 stl_synth_flags,
true);
735 "libc++ std::initializer_list synthetic children",
736 ConstString(
"^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
739 "libc++ std::queue synthetic children",
740 ConstString(
"^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
741 stl_synth_flags,
true);
743 "libc++ std::tuple synthetic children",
744 ConstString(
"^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
745 stl_synth_flags,
true);
747 "libc++ std::optional synthetic children",
748 ConstString(
"^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
749 stl_synth_flags,
true);
751 "libc++ std::variant synthetic children",
752 ConstString(
"^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
753 stl_synth_flags,
true);
757 "libc++ std::atomic synthetic children",
758 ConstString(
"^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags,
true);
760 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
764 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
769 "shared_ptr synthetic children",
770 ConstString(
"^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
771 stl_synth_flags,
true);
774 "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$");
778 "unique_ptr synthetic children", libcxx_std_unique_ptr_regex,
779 stl_synth_flags,
true);
784 "weak_ptr synthetic children",
785 ConstString(
"^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
786 stl_synth_flags,
true);
789 "libc++ std::function summary provider",
790 ConstString(
"^std::__[[:alnum:]]+::function<.+>$"),
791 stl_summary_flags,
true);
797 "libc++ std::bitset summary provider",
798 ConstString(
"^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
799 stl_summary_flags,
true);
802 "libc++ std::vector summary provider",
803 ConstString(
"^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
804 stl_summary_flags,
true);
807 "libc++ std::list summary provider",
808 ConstString(
"^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
809 stl_summary_flags,
true);
812 "libc++ std::list summary provider",
815 ConstString(
"^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
816 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
817 stl_summary_flags,
true);
820 "libc++ std::map summary provider",
821 ConstString(
"^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
822 stl_summary_flags,
true);
825 "libc++ std::deque summary provider",
826 ConstString(
"^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
827 stl_summary_flags,
true);
830 "libc++ std::queue summary provider",
831 ConstString(
"^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
832 stl_summary_flags,
true);
835 "libc++ std::set summary provider",
836 ConstString(
"^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
837 stl_summary_flags,
true);
840 "libc++ std::multiset summary provider",
841 ConstString(
"^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
842 stl_summary_flags,
true);
845 "libc++ std::multimap summary provider",
846 ConstString(
"^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
847 stl_summary_flags,
true);
850 "libc++ std::unordered containers summary provider",
851 ConstString(
"^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
852 stl_summary_flags,
true);
854 "libc++ std::tuple summary provider",
855 ConstString(
"^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
856 stl_summary_flags,
true);
859 "libc++ std::atomic summary provider",
861 stl_summary_flags,
true);
864 "libc++ std::optional summary provider",
865 ConstString(
"^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
866 stl_summary_flags,
true);
869 "libc++ std::variant summary provider",
870 ConstString(
"^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
871 stl_summary_flags,
true);
877 "libc++ std::shared_ptr summary provider",
878 ConstString(
"^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
879 stl_summary_flags,
true);
882 "libc++ std::weak_ptr summary provider",
883 ConstString(
"^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
884 stl_summary_flags,
true);
887 "libc++ std::unique_ptr summary provider",
888 libcxx_std_unique_ptr_regex, stl_summary_flags,
true);
893 "std::vector iterator synthetic children",
894 ConstString(
"^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
900 "std::map iterator synthetic children",
901 ConstString(
"^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags,
906 if (!cpp_category_sp)
918 lldb::TypeSummaryImplSP std_string_summary_sp(
923 "libstdc++ c++11 std::string summary provider"));
926 "libstdc++ c++11 std::wstring summary provider"));
928 cpp_category_sp->GetTypeSummariesContainer()->Add(
ConstString(
"std::string"),
929 std_string_summary_sp);
930 cpp_category_sp->GetTypeSummariesContainer()->Add(
931 ConstString(
"std::basic_string<char>"), std_string_summary_sp);
932 cpp_category_sp->GetTypeSummariesContainer()->Add(
933 ConstString(
"std::basic_string<char,std::char_traits<char>,std::"
934 "allocator<char> >"),
935 std_string_summary_sp);
936 cpp_category_sp->GetTypeSummariesContainer()->Add(
937 ConstString(
"std::basic_string<char, std::char_traits<char>, "
938 "std::allocator<char> >"),
939 std_string_summary_sp);
941 cpp_category_sp->GetTypeSummariesContainer()->Add(
942 ConstString(
"std::__cxx11::string"), cxx11_string_summary_sp);
943 cpp_category_sp->GetTypeSummariesContainer()->Add(
944 ConstString(
"std::__cxx11::basic_string<char, std::char_traits<char>, "
945 "std::allocator<char> >"),
946 cxx11_string_summary_sp);
947 cpp_category_sp->GetTypeSummariesContainer()->Add(
948 ConstString(
"std::__cxx11::basic_string<unsigned char, "
949 "std::char_traits<unsigned char>, "
950 "std::allocator<unsigned char> >"),
951 cxx11_string_summary_sp);
955 lldb::TypeSummaryImplSP std_wstring_summary_sp(
958 cpp_category_sp->GetTypeSummariesContainer()->Add(
ConstString(
"std::wstring"),
959 std_wstring_summary_sp);
960 cpp_category_sp->GetTypeSummariesContainer()->Add(
961 ConstString(
"std::basic_string<wchar_t>"), std_wstring_summary_sp);
962 cpp_category_sp->GetTypeSummariesContainer()->Add(
963 ConstString(
"std::basic_string<wchar_t,std::char_traits<wchar_t>,std::"
964 "allocator<wchar_t> >"),
965 std_wstring_summary_sp);
966 cpp_category_sp->GetTypeSummariesContainer()->Add(
967 ConstString(
"std::basic_string<wchar_t, std::char_traits<wchar_t>, "
968 "std::allocator<wchar_t> >"),
969 std_wstring_summary_sp);
971 cpp_category_sp->GetTypeSummariesContainer()->Add(
972 ConstString(
"std::__cxx11::wstring"), cxx11_wstring_summary_sp);
973 cpp_category_sp->GetTypeSummariesContainer()->Add(
975 "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
976 cxx11_wstring_summary_sp);
984 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
988 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
989 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
993 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
994 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
998 "lldb.formatters.cpp.gnu_libstdcpp.StdDequeSynthProvider")));
999 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
1003 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1004 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
1008 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1009 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
1013 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1014 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
1018 "lldb.formatters.cpp.gnu_libstdcpp.StdUnorderedMapSynthProvider")));
1019 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
1023 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
1024 cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
1028 "lldb.formatters.cpp.gnu_libstdcpp.StdForwardListSynthProvider")));
1032 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1036 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1040 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1044 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1048 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1052 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1056 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1060 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1064 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1068 cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1071 new ScriptSummaryFormat(stl_summary_flags,
"lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider")));
1076 "std::vector iterator synthetic children",
1077 ConstString(
"^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags,
true);
1082 "std::map iterator synthetic children",
1083 ConstString(
"^std::_Rb_tree_iterator<.+>$"), stl_synth_flags,
true);
1088 "std::unique_ptr synthetic children",
1089 ConstString(
"^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags,
true);
1093 "std::shared_ptr synthetic children",
1094 ConstString(
"^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags,
true);
1098 "std::weak_ptr synthetic children",
1099 ConstString(
"^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags,
true);
1103 "std::tuple synthetic children",
ConstString(
"^std::tuple<.+>(( )?&)?$"),
1104 stl_synth_flags,
true);
1109 "std::bitset synthetic child",
ConstString(
"^std::bitset<.+>(( )?&)?$"),
1110 stl_deref_flags,
true);
1115 "std::optional synthetic child",
1116 ConstString(
"^std::optional<.+>(( )?&)?$"), stl_deref_flags,
true);
1120 "libstdc++ std::unique_ptr summary provider",
1121 ConstString(
"^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
1125 "libstdc++ std::shared_ptr summary provider",
1126 ConstString(
"^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
1130 "libstdc++ std::weak_ptr summary provider",
1131 ConstString(
"^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
1135 "libstd++ std::optional summary provider",
1136 ConstString(
"^std::optional<.+>(( )?&)?$"), stl_summary_flags,
true);
1140 if (!cpp_category_sp)
1163 "char8_t * summary provider",
ConstString(
"char8_t *"), string_flags);
1166 "char8_t [] summary provider",
1167 ConstString(
"char8_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1171 "char16_t * summary provider",
ConstString(
"char16_t *"), string_flags);
1174 "char16_t [] summary provider",
1175 ConstString(
"char16_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1179 "char32_t * summary provider",
ConstString(
"char32_t *"), string_flags);
1182 "char32_t [] summary provider",
1183 ConstString(
"char32_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1187 "wchar_t * summary provider",
ConstString(
"wchar_t *"), string_flags);
1190 "wchar_t * summary provider",
1191 ConstString(
"wchar_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1195 "unichar * summary provider",
ConstString(
"unichar *"), string_flags);
1207 "char8_t summary provider",
ConstString(
"char8_t"),
1211 "char16_t summary provider",
ConstString(
"char16_t"), widechar_flags);
1214 "char32_t summary provider",
ConstString(
"char32_t"), widechar_flags);
1216 "wchar_t summary provider",
ConstString(
"wchar_t"),
1221 "unichar summary provider",
ConstString(
"unichar"), widechar_flags);
1224 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
1229 if (!Language::LanguageIsC(lang_type) &&
1230 !Language::LanguageIsCPlusPlus(lang_type))
1238 return std::unique_ptr<TypeScavenger>(
new CPlusPlusTypeScavenger());
1241 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
1242 static llvm::once_flag g_initialize;
1243 static TypeCategoryImplSP g_category;
1245 llvm::call_once(g_initialize, [
this]() ->
void {
1246 DataVisualization::Categories::GetCategory(
ConstString(GetPluginName()),
1258 CPlusPlusLanguage::GetHardcodedSummaries() {
1259 static llvm::once_flag g_initialize;
1263 llvm::call_once(g_initialize, []() ->
void {
1264 g_formatters.push_back(
1271 "Function pointer summary provider"));
1273 return formatter_sp;
1277 g_formatters.push_back(
1284 .SetDontShowChildren(
true)
1285 .SetHideItemNames(
true)
1286 .SetShowMembersOneLiner(
true)
1287 .SetSkipPointers(
true)
1288 .SetSkipReferences(
false),
1290 "vector_type pointer summary provider"));
1292 if (fmt_mgr.
GetCategory(g_vectortypes)->IsEnabled())
1293 return formatter_sp;
1297 g_formatters.push_back(
1304 .SetDontShowChildren(
true)
1305 .SetHideItemNames(
true)
1306 .SetShowMembersOneLiner(
true)
1307 .SetSkipPointers(
true)
1308 .SetSkipReferences(
false),
1310 "block pointer summary provider"));
1312 return formatter_sp;
1318 return g_formatters;
1322 CPlusPlusLanguage::GetHardcodedSynthetics() {
1323 static llvm::once_flag g_initialize;
1327 llvm::call_once(g_initialize, []() ->
void {
1331 static CXXSyntheticChildren::SharedPointer formatter_sp(
1335 .SetSkipPointers(
true)
1336 .SetSkipReferences(
true)
1337 .SetNonCacheable(
true),
1338 "vector_type synthetic children",
1341 if (fmt_mgr.
GetCategory(g_vectortypes)->IsEnabled())
1342 return formatter_sp;
1349 static CXXSyntheticChildren::SharedPointer formatter_sp(
1353 .SetSkipPointers(
true)
1354 .SetSkipReferences(
true)
1355 .SetNonCacheable(
true),
1356 "block pointer synthetic children",
1359 return formatter_sp;
1365 return g_formatters;
1368 bool CPlusPlusLanguage::IsNilReference(
ValueObject &valobj) {
1372 bool canReadValue =
true;
1374 return canReadValue && isZero;
1377 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path)
const {
1378 const auto suffixes = {
".cpp",
".cxx",
".c++",
".cc",
".c",
1379 ".h",
".hh",
".hpp",
".hxx",
".h++"};
1380 for (
auto suffix : suffixes) {
1381 if (file_path.endswith_insensitive(suffix))
1387 return file_path.contains(
"/usr/include/c++/");