19#include "llvm/ADT/StringRef.h"
20#include "llvm/Demangle/ItaniumDemangle.h"
65 const char *mangled_name = mangled.GetMangledName().GetCString();
70 Mangled mangled)
const {
71 const char *mangled_name_cstr = mangled.GetMangledName().
GetCString();
72 ConstString demangled_name = mangled.GetDemangledName();
73 if (demangled_name && mangled_name_cstr && mangled_name_cstr[0]) {
74 if (mangled_name_cstr[0] ==
'_' && mangled_name_cstr[1] ==
'Z' &&
75 (mangled_name_cstr[2] !=
'T' &&
78 mangled_name_cstr[2] !=
'G' &&
79 mangled_name_cstr[2] !=
'Z'))
85 std::string shortname;
87 shortname = cxx_method.
GetContext().str() +
"::";
94 return demangled_name;
95 return mangled.GetMangledName();
120 const llvm::StringRef &left_right_chars,
121 size_t &left_pos,
size_t &right_pos,
122 size_t pos = llvm::StringRef::npos) {
123 assert(left_right_chars.size() == 2);
124 left_pos = llvm::StringRef::npos;
125 const char left_char = left_right_chars[0];
126 const char right_char = left_right_chars[1];
127 pos = s.find_last_of(left_right_chars, pos);
128 if (pos == llvm::StringRef::npos || s[pos] == left_char)
132 while (pos > 0 && depth > 0) {
133 pos = s.find_last_of(left_right_chars, pos);
134 if (pos == llvm::StringRef::npos)
136 if (s[pos] == left_char) {
139 return left_pos < right_pos;
141 }
else if (s[pos] == right_char) {
154 if (basename.size() > 0 && basename[0] ==
'~')
157 if (basename.size() <= idx)
160 if (!std::isalpha(basename[idx]) && basename[idx] !=
'_')
166 while (idx < basename.size()) {
167 if (!std::isalnum(basename[idx]) && basename[idx] !=
'_')
173 return idx == basename.size();
180 char const *full_name,
185 if (!cpp_method.IsValid())
188 llvm::StringRef return_type = cpp_method.GetReturnType();
189 if (!return_type.empty()) {
194 out_stream.
PutCString(cpp_method.GetScopeQualifiedName());
201 llvm::StringRef qualifiers = cpp_method.GetQualifiers();
202 if (!qualifiers.empty()) {
215 size_t arg_start, arg_end;
216 llvm::StringRef full(m_full.GetCString());
217 llvm::StringRef parens(
"()", 2);
219 m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
220 if (arg_end + 1 < full.size())
221 m_qualifiers = full.substr(arg_end + 1).ltrim();
225 size_t basename_end = arg_start;
226 size_t context_start = 0;
227 size_t context_end = full.rfind(
':', basename_end);
228 if (context_end == llvm::StringRef::npos)
229 m_basename = full.substr(0, basename_end);
231 if (context_start < context_end)
232 m_context = full.substr(context_start, context_end - 1 - context_start);
233 const size_t basename_begin = context_end + 1;
234 m_basename = full.substr(basename_begin, basename_end - basename_begin);
242 m_context = llvm::StringRef();
243 m_basename = llvm::StringRef();
244 m_arguments = llvm::StringRef();
245 m_qualifiers = llvm::StringRef();
246 m_return_type = llvm::StringRef();
254 if (!m_parsed && m_full) {
255 if (TrySimplifiedParse()) {
256 m_parse_error =
false;
260 m_basename = function->name.basename;
261 m_context = function->name.context;
262 m_arguments = function->arguments;
263 m_qualifiers = function->qualifiers;
264 m_return_type = function->return_type;
265 m_parse_error =
false;
267 m_parse_error =
true;
301 return m_return_type;
307 if (m_context.empty())
308 return std::string(m_basename);
319 llvm::StringRef basename = GetBasename();
320 size_t arg_start, arg_end;
321 llvm::StringRef parens(
"<>", 2);
323 return basename.substr(0, arg_start);
334 return m_full.GetStringRef().contains(path);
336 llvm::StringRef identifier;
337 llvm::StringRef context;
338 std::string path_str = path.str();
344 return m_full.GetStringRef().contains(path);
359 if (GetBasename() != identifier &&
360 GetBasenameNoTemplateParameters() != identifier)
367 if (m_context.empty())
370 llvm::StringRef haystack = m_context;
371 if (!haystack.consume_back(context))
373 if (haystack.empty() || !isalnum(haystack.back()))
383 Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
385 if (scheme == Mangled::eManglingSchemeNone)
398 const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
405 identifier = full_name->basename;
406 context = full_name->context;
414 llvm::BumpPtrAllocator Alloc;
417 void reset() { Alloc.Reset(); }
419 template <
typename T,
typename...
Args> T *makeNode(
Args &&... args) {
420 return new (Alloc.Allocate(
sizeof(T),
alignof(T)))
421 T(std::forward<Args>(args)...);
424 void *allocateNodeArray(
size_t sz) {
425 return Alloc.Allocate(
sizeof(llvm::itanium_demangle::Node *) * sz,
426 alignof(llvm::itanium_demangle::Node *));
430template <
typename Derived>
431class ManglingSubstitutor
432 :
public llvm::itanium_demangle::AbstractManglingParser<Derived,
435 llvm::itanium_demangle::AbstractManglingParser<Derived, NodeAllocator>;
438 ManglingSubstitutor() :
Base(nullptr, nullptr) {}
440 template <
typename... Ts>
441 ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) {
442 this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...);
443 return substituteImpl(Mangled);
447 void reset(llvm::StringRef Mangled) {
448 Base::reset(Mangled.begin(), Mangled.end());
449 Written = Mangled.begin();
454 ConstString substituteImpl(llvm::StringRef Mangled) {
456 if (this->parse() ==
nullptr) {
457 LLDB_LOG(log,
"Failed to substitute mangling in {0}", Mangled);
464 appendUnchangedInput();
465 LLDB_LOG(log,
"Substituted mangling {0} -> {1}", Mangled, Result);
469 void trySubstitute(llvm::StringRef From, llvm::StringRef To) {
470 if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From))
474 appendUnchangedInput();
478 Written += From.size();
485 const char *Written =
"";
487 llvm::SmallString<128> Result;
490 bool Substituted =
false;
492 const char *currentParserPos()
const {
return this->First; }
494 void appendUnchangedInput() {
496 llvm::StringRef(Written, std::distance(Written, currentParserPos()));
497 Written = currentParserPos();
503class TypeSubstitutor :
public ManglingSubstitutor<TypeSubstitutor> {
504 llvm::StringRef Search;
505 llvm::StringRef Replace;
508 void reset(llvm::StringRef Mangled, llvm::StringRef Search,
509 llvm::StringRef Replace) {
510 ManglingSubstitutor::reset(Mangled);
511 this->Search = Search;
512 this->Replace = Replace;
515 llvm::itanium_demangle::Node *parseType() {
516 trySubstitute(Search, Replace);
517 return ManglingSubstitutor::parseType();
521class CtorDtorSubstitutor :
public ManglingSubstitutor<CtorDtorSubstitutor> {
523 llvm::itanium_demangle::Node *
524 parseCtorDtorName(llvm::itanium_demangle::Node *&SoFar, NameState *
State) {
525 trySubstitute(
"C1",
"C2");
526 trySubstitute(
"D1",
"D2");
527 return ManglingSubstitutor::parseCtorDtorName(SoFar,
State);
534 std::vector<ConstString> alternates;
544 if (!strncmp(mangled_name.
GetCString(),
"_ZN", 3) &&
545 strncmp(mangled_name.
GetCString(),
"_ZNK", 4)) {
546 std::string fixed_scratch(
"_ZNK");
547 fixed_scratch.append(mangled_name.
GetCString() + 3);
552 if (!strncmp(mangled_name.
GetCString(),
"_Z", 2) &&
553 strncmp(mangled_name.
GetCString(),
"_ZL", 3)) {
554 std::string fixed_scratch(
"_ZL");
555 fixed_scratch.append(mangled_name.
GetCString() + 2);
566 alternates.push_back(char_fixup);
571 alternates.push_back(long_fixup);
577 alternates.push_back(ulong_fixup);
580 CtorDtorSubstitutor().substitute(mangled_name.
GetStringRef()))
581 alternates.push_back(ctor_fixup);
588 ConstString demangled = mangled.GetDemangledName();
595 if (!scope_qualified_name.size())
605 std::vector<ConstString> alternates;
608 std::vector<ConstString> param_and_qual_matches;
609 std::vector<ConstString> param_matches;
610 for (
size_t i = 0; i < alternates.size(); i++) {
611 ConstString alternate_mangled_name = alternates[i];
612 Mangled mangled(alternate_mangled_name);
613 ConstString demangled = mangled.GetDemangledName();
621 param_and_qual_matches.push_back(alternate_mangled_name);
623 param_matches.push_back(alternate_mangled_name);
627 if (param_and_qual_matches.size())
628 return param_and_qual_matches[0];
630 else if (param_matches.size())
631 return param_matches[0];
637 if (!cpp_category_sp)
651 "std::string summary provider",
652 ConstString(
"^std::__[[:alnum:]]+::string$"), stl_summary_flags,
656 "std::string summary provider",
657 ConstString(
"^std::__[[:alnum:]]+::basic_string<char, "
658 "std::__[[:alnum:]]+::char_traits<char>, "
659 "std::__[[:alnum:]]+::allocator<char> >$"),
660 stl_summary_flags,
true);
663 "std::string summary provider",
664 ConstString(
"^std::__[[:alnum:]]+::basic_string<unsigned char, "
665 "std::__[[:alnum:]]+::char_traits<unsigned char>, "
666 "std::__[[:alnum:]]+::allocator<unsigned char> >$"),
667 stl_summary_flags,
true);
671 "std::u16string summary provider",
672 ConstString(
"^std::__[[:alnum:]]+::basic_string<char16_t, "
673 "std::__[[:alnum:]]+::char_traits<char16_t>, "
674 "std::__[[:alnum:]]+::allocator<char16_t> >$"),
675 stl_summary_flags,
true);
679 "std::u32string summary provider",
680 ConstString(
"^std::__[[:alnum:]]+::basic_string<char32_t, "
681 "std::__[[:alnum:]]+::char_traits<char32_t>, "
682 "std::__[[:alnum:]]+::allocator<char32_t> >$"),
683 stl_summary_flags,
true);
687 "std::wstring summary provider",
688 ConstString(
"^std::__[[:alnum:]]+::wstring$"), stl_summary_flags,
true);
691 "std::wstring summary provider",
692 ConstString(
"^std::__[[:alnum:]]+::basic_string<wchar_t, "
693 "std::__[[:alnum:]]+::char_traits<wchar_t>, "
694 "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
695 stl_summary_flags,
true);
699 "std::string_view summary provider",
701 stl_summary_flags,
true);
704 "std::string_view summary provider",
705 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<char, "
706 "std::__[[:alnum:]]+::char_traits<char> >$"),
707 stl_summary_flags,
true);
711 "std::string_view summary provider",
712 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<unsigned char, "
713 "std::__[[:alnum:]]+::char_traits<unsigned char> >$"),
714 stl_summary_flags,
true);
718 "std::u16string_view summary provider",
719 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<char16_t, "
720 "std::__[[:alnum:]]+::char_traits<char16_t> >$"),
721 stl_summary_flags,
true);
725 "std::u32string_view summary provider",
726 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<char32_t, "
727 "std::__[[:alnum:]]+::char_traits<char32_t> >$"),
728 stl_summary_flags,
true);
732 "std::wstring_view summary provider",
733 ConstString(
"^std::__[[:alnum:]]+::wstring_view$"),
734 stl_summary_flags,
true);
737 "std::wstring_view summary provider",
738 ConstString(
"^std::__[[:alnum:]]+::basic_string_view<wchar_t, "
739 "std::__[[:alnum:]]+::char_traits<wchar_t> >$"),
740 stl_summary_flags,
true);
751 "libc++ std::bitset synthetic children",
752 ConstString(
"^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
757 "libc++ std::vector synthetic children",
758 ConstString(
"^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
763 "libc++ std::forward_list synthetic children",
764 ConstString(
"^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
765 stl_synth_flags,
true);
769 "libc++ std::list synthetic children",
772 ConstString(
"^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
773 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
774 stl_deref_flags,
true);
778 "libc++ std::map synthetic children",
779 ConstString(
"^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
784 "libc++ std::set synthetic children",
785 ConstString(
"^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
790 "libc++ std::multiset synthetic children",
791 ConstString(
"^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
792 stl_deref_flags,
true);
796 "libc++ std::multimap synthetic children",
797 ConstString(
"^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
798 stl_synth_flags,
true);
802 "libc++ std::unordered containers synthetic children",
803 ConstString(
"^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
804 stl_synth_flags,
true);
808 "libc++ std::initializer_list synthetic children",
809 ConstString(
"^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
812 "libc++ std::queue synthetic children",
813 ConstString(
"^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
814 stl_synth_flags,
true);
816 "libc++ std::tuple synthetic children",
817 ConstString(
"^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
818 stl_synth_flags,
true);
820 "libc++ std::optional synthetic children",
821 ConstString(
"^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
822 stl_synth_flags,
true);
824 "libc++ std::variant synthetic children",
825 ConstString(
"^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
826 stl_synth_flags,
true);
830 "libc++ std::atomic synthetic children",
831 ConstString(
"^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags,
true);
835 "libc++ std::span synthetic children",
836 ConstString(
"^std::__[[:alnum:]]+::span<.+>(( )?&)?$"), stl_deref_flags,
841 "libc++ std::ranges::ref_view synthetic children",
842 ConstString(
"^std::__[[:alnum:]]+::ranges::ref_view<.+>(( )?&)?$"),
843 stl_deref_flags,
true);
845 cpp_category_sp->AddTypeSynthetic(
849 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
854 "shared_ptr synthetic children",
855 ConstString(
"^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
856 stl_synth_flags,
true);
859 "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$");
863 "unique_ptr synthetic children", libcxx_std_unique_ptr_regex,
864 stl_synth_flags,
true);
869 "weak_ptr synthetic children",
870 ConstString(
"^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
871 stl_synth_flags,
true);
874 "libc++ std::function summary provider",
875 ConstString(
"^std::__[[:alnum:]]+::function<.+>$"),
876 stl_summary_flags,
true);
879 "^std::__[[:alnum:]]+::coroutine_handle<.+>(( )?&)?$");
883 "coroutine_handle synthetic children", libcxx_std_coroutine_handle_regex,
884 stl_deref_flags,
true);
890 "libc++ std::bitset summary provider",
891 ConstString(
"^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
892 stl_summary_flags,
true);
895 "libc++ std::vector summary provider",
896 ConstString(
"^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
897 stl_summary_flags,
true);
900 "libc++ std::list summary provider",
901 ConstString(
"^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
902 stl_summary_flags,
true);
905 "libc++ std::list summary provider",
908 ConstString(
"^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
909 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
910 stl_summary_flags,
true);
913 "libc++ std::map summary provider",
914 ConstString(
"^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
915 stl_summary_flags,
true);
918 "libc++ std::deque summary provider",
919 ConstString(
"^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
920 stl_summary_flags,
true);
923 "libc++ std::queue summary provider",
924 ConstString(
"^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
925 stl_summary_flags,
true);
928 "libc++ std::set summary provider",
929 ConstString(
"^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
930 stl_summary_flags,
true);
933 "libc++ std::multiset summary provider",
934 ConstString(
"^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
935 stl_summary_flags,
true);
938 "libc++ std::multimap summary provider",
939 ConstString(
"^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
940 stl_summary_flags,
true);
943 "libc++ std::unordered containers summary provider",
944 ConstString(
"^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
945 stl_summary_flags,
true);
947 "libc++ std::tuple summary provider",
948 ConstString(
"^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
949 stl_summary_flags,
true);
952 "libc++ std::atomic summary provider",
954 stl_summary_flags,
true);
957 "libc++ std::optional summary provider",
958 ConstString(
"^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
959 stl_summary_flags,
true);
962 "libc++ std::variant summary provider",
963 ConstString(
"^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
964 stl_summary_flags,
true);
967 "libc++ std::span summary provider",
968 ConstString(
"^std::__[[:alnum:]]+::span<.+>(( )?&)?$"),
969 stl_summary_flags,
true);
975 "libc++ std::shared_ptr summary provider",
976 ConstString(
"^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
977 stl_summary_flags,
true);
980 "libc++ std::weak_ptr summary provider",
981 ConstString(
"^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
982 stl_summary_flags,
true);
985 "libc++ std::unique_ptr summary provider",
986 libcxx_std_unique_ptr_regex, stl_summary_flags,
true);
990 "libc++ std::coroutine_handle summary provider",
991 libcxx_std_coroutine_handle_regex, stl_summary_flags,
true);
996 "std::vector iterator synthetic children",
997 ConstString(
"^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
1003 "std::map iterator synthetic children",
1004 ConstString(
"^std::__[[:alnum:]]+::__map_(const_)?iterator<.+>$"), stl_synth_flags,
1011 "std::unordered_map iterator synthetic children",
1012 ConstString(
"^std::__[[:alnum:]]+::__hash_map_(const_)?iterator<.+>$"),
1013 stl_synth_flags,
true);
1017 if (!cpp_category_sp)
1029 lldb::TypeSummaryImplSP std_string_summary_sp(
1034 "libstdc++ c++11 std::string summary provider"));
1037 "libstdc++ c++11 std::wstring summary provider"));
1040 std_string_summary_sp);
1041 cpp_category_sp->AddTypeSummary(
"std::basic_string<char>",
1043 cpp_category_sp->AddTypeSummary(
1044 "std::basic_string<char,std::char_traits<char>,std::allocator<char> >",
1046 cpp_category_sp->AddTypeSummary(
1047 "std::basic_string<char, std::char_traits<char>, std::allocator<char> >",
1051 cxx11_string_summary_sp);
1052 cpp_category_sp->AddTypeSummary(
1053 "std::__cxx11::basic_string<char, std::char_traits<char>, "
1054 "std::allocator<char> >",
1056 cpp_category_sp->AddTypeSummary(
"std::__cxx11::basic_string<unsigned char, "
1057 "std::char_traits<unsigned char>, "
1058 "std::allocator<unsigned char> >",
1060 cxx11_string_summary_sp);
1064 lldb::TypeSummaryImplSP std_wstring_summary_sp(
1068 std_wstring_summary_sp);
1069 cpp_category_sp->AddTypeSummary(
"std::basic_string<wchar_t>",
1071 cpp_category_sp->AddTypeSummary(
"std::basic_string<wchar_t,std::char_traits<"
1072 "wchar_t>,std::allocator<wchar_t> >",
1074 cpp_category_sp->AddTypeSummary(
1075 "std::basic_string<wchar_t, std::char_traits<wchar_t>, "
1076 "std::allocator<wchar_t> >",
1080 cxx11_wstring_summary_sp);
1081 cpp_category_sp->AddTypeSummary(
1082 "std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, "
1083 "std::allocator<wchar_t> >",
1092 cpp_category_sp->AddTypeSynthetic(
1096 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
1097 cpp_category_sp->AddTypeSynthetic(
1101 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1102 cpp_category_sp->AddTypeSynthetic(
1106 "lldb.formatters.cpp.gnu_libstdcpp.StdDequeSynthProvider")));
1107 cpp_category_sp->AddTypeSynthetic(
1111 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1112 cpp_category_sp->AddTypeSynthetic(
1116 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1117 cpp_category_sp->AddTypeSynthetic(
1121 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1122 cpp_category_sp->AddTypeSynthetic(
1126 "lldb.formatters.cpp.gnu_libstdcpp.StdUnorderedMapSynthProvider")));
1127 cpp_category_sp->AddTypeSynthetic(
1131 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
1132 cpp_category_sp->AddTypeSynthetic(
1136 "lldb.formatters.cpp.gnu_libstdcpp.StdForwardListSynthProvider")));
1140 cpp_category_sp->AddTypeSummary(
"^std::bitset<.+>(( )?&)?$",
1143 stl_summary_flags,
"size=${svar%#}")));
1144 cpp_category_sp->AddTypeSummary(
"^std::vector<.+>(( )?&)?$",
1147 stl_summary_flags,
"size=${svar%#}")));
1148 cpp_category_sp->AddTypeSummary(
"^std::map<.+> >(( )?&)?$",
1151 stl_summary_flags,
"size=${svar%#}")));
1152 cpp_category_sp->AddTypeSummary(
"^std::set<.+> >(( )?&)?$",
1155 stl_summary_flags,
"size=${svar%#}")));
1156 cpp_category_sp->AddTypeSummary(
"^std::deque<.+>(( )?&)?$",
1159 stl_summary_flags,
"size=${svar%#}")));
1160 cpp_category_sp->AddTypeSummary(
"^std::multimap<.+> >(( )?&)?$",
1163 stl_summary_flags,
"size=${svar%#}")));
1164 cpp_category_sp->AddTypeSummary(
"^std::multiset<.+> >(( )?&)?$",
1167 stl_summary_flags,
"size=${svar%#}")));
1168 cpp_category_sp->AddTypeSummary(
"^std::unordered_(multi)?(map|set)<.+> >$",
1171 stl_summary_flags,
"size=${svar%#}")));
1172 cpp_category_sp->AddTypeSummary(
"^std::(__cxx11::)?list<.+>(( )?&)?$",
1175 stl_summary_flags,
"size=${svar%#}")));
1176 cpp_category_sp->AddTypeSummary(
1180 "lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider")));
1185 "std::vector iterator synthetic children",
1186 ConstString(
"^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags,
true);
1191 "std::map iterator synthetic children",
1192 ConstString(
"^std::_Rb_tree_iterator<.+>$"), stl_synth_flags,
true);
1197 "std::unique_ptr synthetic children",
1198 ConstString(
"^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags,
true);
1202 "std::shared_ptr synthetic children",
1203 ConstString(
"^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags,
true);
1207 "std::weak_ptr synthetic children",
1208 ConstString(
"^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags,
true);
1212 "std::tuple synthetic children",
ConstString(
"^std::tuple<.+>(( )?&)?$"),
1213 stl_synth_flags,
true);
1216 "^std::coroutine_handle<.+>(( )?&)?$");
1220 "std::coroutine_handle synthetic children",
1221 libstdcpp_std_coroutine_handle_regex, stl_deref_flags,
true);
1226 "std::bitset synthetic child",
ConstString(
"^std::bitset<.+>(( )?&)?$"),
1227 stl_deref_flags,
true);
1232 "std::optional synthetic child",
1233 ConstString(
"^std::optional<.+>(( )?&)?$"), stl_deref_flags,
true);
1237 "libstdc++ std::unique_ptr summary provider",
1238 ConstString(
"^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
1242 "libstdc++ std::shared_ptr summary provider",
1243 ConstString(
"^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
1247 "libstdc++ std::weak_ptr summary provider",
1248 ConstString(
"^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
1252 "libstdc++ std::coroutine_handle summary provider",
1253 libstdcpp_std_coroutine_handle_regex, stl_summary_flags,
true);
1256 "libstd++ std::optional summary provider",
1257 ConstString(
"^std::optional<.+>(( )?&)?$"), stl_summary_flags,
true);
1261 if (!cpp_category_sp)
1284 "char8_t * summary provider",
ConstString(
"char8_t *"), string_flags);
1287 "char8_t [] summary provider",
1288 ConstString(
"char8_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1292 "char16_t * summary provider",
ConstString(
"char16_t *"), string_flags);
1295 "char16_t [] summary provider",
1296 ConstString(
"char16_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1300 "char32_t * summary provider",
ConstString(
"char32_t *"), string_flags);
1303 "char32_t [] summary provider",
1304 ConstString(
"char32_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1308 "wchar_t * summary provider",
ConstString(
"wchar_t *"), string_flags);
1311 "wchar_t * summary provider",
1312 ConstString(
"wchar_t ?\\[[0-9]+\\]"), string_array_flags,
true);
1316 "unichar * summary provider",
ConstString(
"unichar *"), string_flags);
1328 "char8_t summary provider",
ConstString(
"char8_t"),
1332 "char16_t summary provider",
ConstString(
"char16_t"), widechar_flags);
1335 "char32_t summary provider",
ConstString(
"char32_t"), widechar_flags);
1337 "wchar_t summary provider",
ConstString(
"wchar_t"),
1342 "unichar summary provider",
ConstString(
"unichar"), widechar_flags);
1359 return std::unique_ptr<TypeScavenger>(
new CPlusPlusTypeScavenger());
1363 static llvm::once_flag g_initialize;
1364 static TypeCategoryImplSP g_category;
1366 llvm::call_once(g_initialize, [
this]() ->
void {
1380 static llvm::once_flag g_initialize;
1384 llvm::call_once(g_initialize, []() ->
void {
1385 g_formatters.push_back(
1392 "Function pointer summary provider"));
1395 return formatter_sp;
1399 g_formatters.push_back(
1406 .SetDontShowChildren(
true)
1407 .SetHideItemNames(
true)
1408 .SetShowMembersOneLiner(
true)
1409 .SetSkipPointers(
true)
1410 .SetSkipReferences(
false),
1412 "vector_type pointer summary provider"));
1414 if (fmt_mgr.
GetCategory(g_vectortypes)->IsEnabled())
1415 return formatter_sp;
1419 g_formatters.push_back(
1426 .SetDontShowChildren(
true)
1427 .SetHideItemNames(
true)
1428 .SetShowMembersOneLiner(
true)
1429 .SetSkipPointers(
true)
1430 .SetSkipReferences(
false),
1432 "block pointer summary provider"));
1434 return formatter_sp;
1440 return g_formatters;
1445 static llvm::once_flag g_initialize;
1449 llvm::call_once(g_initialize, []() ->
void {
1457 .SetSkipPointers(
true)
1458 .SetSkipReferences(
true)
1459 .SetNonCacheable(
true),
1460 "vector_type synthetic children",
1463 if (fmt_mgr.
GetCategory(g_vectortypes)->IsEnabled())
1464 return formatter_sp;
1475 .SetSkipPointers(
true)
1476 .SetSkipReferences(
true)
1477 .SetNonCacheable(
true),
1478 "block pointer synthetic children",
1481 return formatter_sp;
1487 return g_formatters;
1494 bool canReadValue =
true;
1496 return canReadValue && isZero;
1500 const auto suffixes = {
".cpp",
".cxx",
".c++",
".cc",
".c",
1501 ".h",
".hh",
".hpp",
".hxx",
".h++"};
1502 for (
auto suffix : suffixes) {
1503 if (file_path.endswith_insensitive(suffix))
1509 return file_path.contains(
"/usr/include/c++/");
1515 switch (representation) {
1524 VariableListSP variable_list_sp;
1525 bool get_function_vars =
true;
1530 get_function_vars =
false;
1537 if (get_function_vars) {
1549 if (variable_list_sp)
static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
static bool IsTrivialBasename(const llvm::StringRef &basename)
static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
static bool ReverseFindMatchingChars(const llvm::StringRef &s, const llvm::StringRef &left_right_chars, size_t &left_pos, size_t &right_pos, size_t pos=llvm::StringRef::npos)
static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_PLUGIN_DEFINE(PluginName)
static bool IsMSVCUndecoratedName(llvm::StringRef name)
static bool ExtractContextAndIdentifier(llvm::StringRef name, llvm::StringRef &context, llvm::StringRef &identifier)
A command line argument class.
A class that describes a single lexical block.
lldb::VariableListSP GetBlockVariableList(bool can_create)
Get the variable list for this block only.
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
const InlineFunctionInfo * GetInlinedFunctionInfo() const
Get const accessor for any inlined function information.
llvm::StringRef m_arguments
llvm::StringRef m_return_type
llvm::StringRef m_basename
llvm::StringRef GetArguments()
std::string GetScopeQualifiedName()
llvm::StringRef GetContext()
llvm::StringRef m_context
llvm::StringRef m_qualifiers
llvm::StringRef GetQualifiers()
bool ContainsPath(llvm::StringRef path)
llvm::StringRef GetBasename()
bool TrySimplifiedParse()
llvm::StringRef GetReturnType()
Returns the methods return-type.
llvm::StringRef GetBasenameNoTemplateParameters()
Returns the Basename of this method without a template parameter list, if any.
bool GetFunctionDisplayName(const SymbolContext *sc, const ExecutionContext *exe_ctx, FunctionNameRepresentation representation, Stream &s) override
bool IsNilReference(ValueObject &valobj) override
bool IsSourceFile(llvm::StringRef file_path) const override
ConstString GetDemangledFunctionNameWithoutArguments(Mangled mangled) const override
lldb::TypeCategoryImplSP GetFormatters() override
bool SymbolNameFitsToLanguage(Mangled mangled) const override
Returns true iff the given symbol name is compatible with the mangling scheme of this language.
HardcodedFormatters::HardcodedSyntheticFinder GetHardcodedSynthetics() override
static bool IsCPPMangledName(llvm::StringRef name)
llvm::StringRef GetPluginName() override
std::vector< ConstString > GenerateAlternateFunctionManglings(const ConstString mangled) const override
bool DemangledNameContainsPath(llvm::StringRef path, ConstString demangled) const override
ConstString FindBestAlternateFunctionMangledName(const Mangled mangled, const SymbolContext &sym_ctx) const override
static bool ExtractContextAndIdentifier(const char *name, llvm::StringRef &context, llvm::StringRef &identifier)
std::unique_ptr< TypeScavenger > GetTypeScavenger() override
HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries() override
static lldb_private::Language * CreateInstance(lldb::LanguageType language)
CPlusPlusLanguage()=default
std::optional< ParsedFunction > ParseAsFunctionDefinition()
std::optional< ParsedName > ParseAsFullName()
Generic representation of a type in a programming language.
lldb::LanguageType GetMinimumLanguage()
bool IsBlockPointerType(CompilerType *function_pointer_type_ptr=nullptr) const
CompilerType GetTypedefedType() const
If the current object represents a typedef type, get the underlying type.
bool IsFunctionPointerType() const
bool IsTypedefType() const
bool IsVectorType(CompilerType *element_type=nullptr, uint64_t *size=nullptr) const
A uniqued constant string class.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
void Clear()
Clear this object's state.
const char * GetCString() const
Get the string value as a C string.
static bool GetCategory(ConstString category, lldb::TypeCategoryImplSP &entry, bool allow_create=true)
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
ExecutionContextScope * GetBestExecutionContextScope() const
ConstString GetName() const
Block & GetBlock(bool can_create)
Get accessor for the block list.
A class that describes information for an inlined function.
ConstString GetName() const
FunctionNameRepresentation
static bool LanguageIsC(lldb::LanguageType language)
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A stream class that can stream formatted output to a file.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
Block * block
The Block for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
Symbol * symbol
The Symbol for a given query.
Provides public interface for all SymbolFiles.
virtual void GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector< ConstString > &mangled_names)
ConstString GetName() const
Flags & SetSkipReferences(bool value=true)
Flags & SetFrontEndWantsDereference(bool value=true)
Flags & SetSkipPointers(bool value=true)
Flags & SetCascades(bool value=true)
std::shared_ptr< SyntheticChildren > SharedPointer
Flags & SetCascades(bool value=true)
Flags & SetSkipPointers(bool value=true)
Flags & SetHideItemNames(bool value=true)
Flags & SetDontShowChildren(bool value=true)
Flags & SetSkipReferences(bool value=true)
Flags & SetShowMembersOneLiner(bool value=true)
Flags & SetDontShowValue(bool value=true)
std::shared_ptr< TypeSummaryImpl > SharedPointer
CompilerType GetCompilerType()
virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, bool *success=nullptr)
virtual bool IsPointerType()
virtual lldb::LanguageType GetObjectRuntimeLanguage()
size_t AppendVariablesWithScope(lldb::ValueType type, VariableList &var_list, bool if_unique=true)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
LanguageType
Programming language type.
@ eLanguageTypeObjC_plus_plus
Objective-C++.
@ eValueTypeVariableArgument
function argument variables