diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/Plugins/Language')
37 files changed, 10606 insertions, 0 deletions
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp new file mode 100644 index 000000000000..a554aa57d58e --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp @@ -0,0 +1,792 @@ +//===-- CPlusPlusLanguage.cpp --------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "CPlusPlusLanguage.h" + + +#include "llvm/ADT/StringRef.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/RegularExpression.h" +#include "lldb/Core/UniqueCStringMap.h" +#include "lldb/DataFormatters/CXXFunctionPointer.h" +#include "lldb/DataFormatters/DataVisualization.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/VectorType.h" + +#include "CxxStringTypes.h" +#include "LibCxx.h" +#include "LibStdcpp.h" + +#include <cstring> +#include <cctype> +#include <functional> +#include <mutex> + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +void +CPlusPlusLanguage::Initialize() +{ + PluginManager::RegisterPlugin (GetPluginNameStatic(), + "C++ Language", + CreateInstance); +} + +void +CPlusPlusLanguage::Terminate() +{ + PluginManager::UnregisterPlugin (CreateInstance); +} + +lldb_private::ConstString +CPlusPlusLanguage::GetPluginNameStatic() +{ + static ConstString g_name("cplusplus"); + return g_name; +} + + +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +lldb_private::ConstString +CPlusPlusLanguage::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +CPlusPlusLanguage::GetPluginVersion() +{ + return 1; +} + +//------------------------------------------------------------------ +// Static Functions +//------------------------------------------------------------------ +Language * +CPlusPlusLanguage::CreateInstance (lldb::LanguageType language) +{ + if (Language::LanguageIsCPlusPlus(language)) + return new CPlusPlusLanguage(); + return nullptr; +} + +void +CPlusPlusLanguage::MethodName::Clear() +{ + m_full.Clear(); + m_basename = llvm::StringRef(); + m_context = llvm::StringRef(); + m_arguments = llvm::StringRef(); + m_qualifiers = llvm::StringRef(); + m_type = eTypeInvalid; + m_parsed = false; + m_parse_error = false; +} + +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) +{ + assert (left_right_chars.size() == 2); + left_pos = llvm::StringRef::npos; + const char left_char = left_right_chars[0]; + const char right_char = left_right_chars[1]; + pos = s.find_last_of(left_right_chars, pos); + if (pos == llvm::StringRef::npos || s[pos] == left_char) + return false; + right_pos = pos; + uint32_t depth = 1; + while (pos > 0 && depth > 0) + { + pos = s.find_last_of(left_right_chars, pos); + if (pos == llvm::StringRef::npos) + return false; + if (s[pos] == left_char) + { + if (--depth == 0) + { + left_pos = pos; + return left_pos < right_pos; + } + } + else if (s[pos] == right_char) + { + ++depth; + } + } + return false; +} + +static bool +IsValidBasename(const llvm::StringRef& basename) +{ + // Check that the basename matches with the following regular expression or is an operator name: + // "^~?([A-Za-z_][A-Za-z_0-9]*)(<.*>)?$" + // We are using a hand written implementation because it is significantly more efficient then + // using the general purpose regular expression library. + size_t idx = 0; + if (basename.size() > 0 && basename[0] == '~') + idx = 1; + + if (basename.size() <= idx) + return false; // Empty string or "~" + + if (!std::isalpha(basename[idx]) && basename[idx] != '_') + return false; // First charater (after removing the possible '~'') isn't in [A-Za-z_] + + // Read all characters matching [A-Za-z_0-9] + ++idx; + while (idx < basename.size()) + { + if (!std::isalnum(basename[idx]) && basename[idx] != '_') + break; + ++idx; + } + + // We processed all characters. It is a vaild basename. + if (idx == basename.size()) + return true; + + // Check for basename with template arguments + // TODO: Improve the quality of the validation with validating the template arguments + if (basename[idx] == '<' && basename.back() == '>') + return true; + + // Check if the basename is a vaild C++ operator name + if (!basename.startswith("operator")) + return false; + + static RegularExpression g_operator_regex("^(operator)( ?)([A-Za-z_][A-Za-z_0-9]*|\\(\\)|\\[\\]|[\\^<>=!\\/*+-]+)(<.*>)?(\\[\\])?$"); + std::string basename_str(basename.str()); + return g_operator_regex.Execute(basename_str.c_str(), nullptr); +} + +void +CPlusPlusLanguage::MethodName::Parse() +{ + if (!m_parsed && m_full) + { +// ConstString mangled; +// m_full.GetMangledCounterpart(mangled); +// printf ("\n parsing = '%s'\n", m_full.GetCString()); +// if (mangled) +// printf (" mangled = '%s'\n", mangled.GetCString()); + m_parse_error = false; + m_parsed = true; + llvm::StringRef full (m_full.GetCString()); + + size_t arg_start, arg_end; + llvm::StringRef parens("()", 2); + if (ReverseFindMatchingChars (full, parens, arg_start, arg_end)) + { + m_arguments = full.substr(arg_start, arg_end - arg_start + 1); + if (arg_end + 1 < full.size()) + m_qualifiers = full.substr(arg_end + 1); + if (arg_start > 0) + { + size_t basename_end = arg_start; + size_t context_start = 0; + size_t context_end = llvm::StringRef::npos; + if (basename_end > 0 && full[basename_end-1] == '>') + { + // TODO: handle template junk... + // Templated function + size_t template_start, template_end; + llvm::StringRef lt_gt("<>", 2); + if (ReverseFindMatchingChars (full, lt_gt, template_start, template_end, basename_end)) + { + // Check for templated functions that include return type like: 'void foo<Int>()' + context_start = full.rfind(' ', template_start); + if (context_start == llvm::StringRef::npos) + context_start = 0; + + context_end = full.rfind(':', template_start); + if (context_end == llvm::StringRef::npos || context_end < context_start) + context_end = context_start; + } + else + { + context_end = full.rfind(':', basename_end); + } + } + else if (context_end == llvm::StringRef::npos) + { + context_end = full.rfind(':', basename_end); + } + + if (context_end == llvm::StringRef::npos) + m_basename = full.substr(0, basename_end); + else + { + if (context_start < context_end) + m_context = full.substr(context_start, context_end - 1); + const size_t basename_begin = context_end + 1; + m_basename = full.substr(basename_begin, basename_end - basename_begin); + } + m_type = eTypeUnknownMethod; + } + else + { + m_parse_error = true; + return; + } + + if (!IsValidBasename(m_basename)) + { + // The C++ basename doesn't match our regular expressions so this can't + // be a valid C++ method, clear everything out and indicate an error + m_context = llvm::StringRef(); + m_basename = llvm::StringRef(); + m_arguments = llvm::StringRef(); + m_qualifiers = llvm::StringRef(); + m_parse_error = true; + } + } + else + { + m_parse_error = true; + } + } +} + +llvm::StringRef +CPlusPlusLanguage::MethodName::GetBasename () +{ + if (!m_parsed) + Parse(); + return m_basename; +} + +llvm::StringRef +CPlusPlusLanguage::MethodName::GetContext () +{ + if (!m_parsed) + Parse(); + return m_context; +} + +llvm::StringRef +CPlusPlusLanguage::MethodName::GetArguments () +{ + if (!m_parsed) + Parse(); + return m_arguments; +} + +llvm::StringRef +CPlusPlusLanguage::MethodName::GetQualifiers () +{ + if (!m_parsed) + Parse(); + return m_qualifiers; +} + +bool +CPlusPlusLanguage::IsCPPMangledName (const char *name) +{ + // FIXME, we should really run through all the known C++ Language plugins and ask each one if + // this is a C++ mangled name, but we can put that off till there is actually more than one + // we care about. + + if (name && name[0] == '_' && name[1] == 'Z') + return true; + else + return false; +} + +bool +CPlusPlusLanguage::ExtractContextAndIdentifier (const char *name, llvm::StringRef &context, llvm::StringRef &identifier) +{ + static RegularExpression g_basename_regex("^(([A-Za-z_][A-Za-z_0-9]*::)*)([A-Za-z_][A-Za-z_0-9]*)$"); + RegularExpression::Match match(4); + if (g_basename_regex.Execute (name, &match)) + { + match.GetMatchAtIndex(name, 1, context); + match.GetMatchAtIndex(name, 3, identifier); + return true; + } + return false; +} + +class CPPRuntimeEquivalents +{ +public: + CPPRuntimeEquivalents () + { + + m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("basic_string<char>")); + + // these two (with a prefixed std::) occur when c++stdlib string class occurs as a template argument in some STL container + m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("std::basic_string<char>")); + + m_impl.Sort(); + } + + void + Add (ConstString& type_name, + ConstString& type_equivalent) + { + m_impl.Insert(type_name.AsCString(), type_equivalent); + } + + uint32_t + FindExactMatches (ConstString& type_name, + std::vector<ConstString>& equivalents) + { + + uint32_t count = 0; + + for (ImplData match = m_impl.FindFirstValueForName(type_name.AsCString()); + match != NULL; + match = m_impl.FindNextValueForName(match)) + { + equivalents.push_back(match->value); + count++; + } + + return count; + } + + // partial matches can occur when a name with equivalents is a template argument. + // e.g. we may have "class Foo" be a match for "struct Bar". if we have a typename + // such as "class Templatized<class Foo, Anything>" we want this to be replaced with + // "class Templatized<struct Bar, Anything>". Since partial matching is time consuming + // once we get a partial match, we add it to the exact matches list for faster retrieval + uint32_t + FindPartialMatches (ConstString& type_name, + std::vector<ConstString>& equivalents) + { + + uint32_t count = 0; + + const char* type_name_cstr = type_name.AsCString(); + + size_t items_count = m_impl.GetSize(); + + for (size_t item = 0; item < items_count; item++) + { + const char* key_cstr = m_impl.GetCStringAtIndex(item); + if ( strstr(type_name_cstr,key_cstr) ) + { + count += AppendReplacements(type_name_cstr, + key_cstr, + equivalents); + } + } + + return count; + + } + +private: + + std::string& replace (std::string& target, + std::string& pattern, + std::string& with) + { + size_t pos; + size_t pattern_len = pattern.size(); + + while ( (pos = target.find(pattern)) != std::string::npos ) + target.replace(pos, pattern_len, with); + + return target; + } + + uint32_t + AppendReplacements (const char* original, + const char *matching_key, + std::vector<ConstString>& equivalents) + { + + std::string matching_key_str(matching_key); + ConstString original_const(original); + + uint32_t count = 0; + + for (ImplData match = m_impl.FindFirstValueForName(matching_key); + match != NULL; + match = m_impl.FindNextValueForName(match)) + { + std::string target(original); + std::string equiv_class(match->value.AsCString()); + + replace (target, matching_key_str, equiv_class); + + ConstString target_const(target.c_str()); + +// you will most probably want to leave this off since it might make this map grow indefinitely +#ifdef ENABLE_CPP_EQUIVALENTS_MAP_TO_GROW + Add(original_const, target_const); +#endif + equivalents.push_back(target_const); + + count++; + } + + return count; + } + + typedef UniqueCStringMap<ConstString> Impl; + typedef const Impl::Entry* ImplData; + Impl m_impl; +}; + +static CPPRuntimeEquivalents& +GetEquivalentsMap () +{ + static CPPRuntimeEquivalents g_equivalents_map; + return g_equivalents_map; +} + + +uint32_t +CPlusPlusLanguage::FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents) +{ + uint32_t count = GetEquivalentsMap().FindExactMatches(type_name, equivalents); + + bool might_have_partials= + ( count == 0 ) // if we have a full name match just use it + && (strchr(type_name.AsCString(), '<') != NULL // we should only have partial matches when templates are involved, check that we have + && strchr(type_name.AsCString(), '>') != NULL); // angle brackets in the type_name before trying to scan for partial matches + + if ( might_have_partials ) + count = GetEquivalentsMap().FindPartialMatches(type_name, equivalents); + + return count; +} + +static void +LoadLibCxxFormatters (lldb::TypeCategoryImplSP cpp_category_sp) +{ + if (!cpp_category_sp) + return; + + TypeSummaryImpl::Flags stl_summary_flags; + stl_summary_flags.SetCascades(true) + .SetSkipPointers(false) + .SetSkipReferences(false) + .SetDontShowChildren(true) + .SetDontShowValue(true) + .SetShowMembersOneLiner(false) + .SetHideItemNames(false); + +#ifndef LLDB_DISABLE_PYTHON + lldb::TypeSummaryImplSP std_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxStringSummaryProvider, "std::string summary provider")); + lldb::TypeSummaryImplSP std_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxWStringSummaryProvider, "std::wstring summary provider")); + + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::string"), + std_string_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"), + std_string_summary_sp); + + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::wstring"), + std_wstring_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"), + std_wstring_summary_sp); + + SyntheticChildren::Flags stl_synth_flags; + stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false); + + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__1::map<.+> >(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_synth_flags); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__1::set<.+> >(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, "libc++ std::initializer_list synthetic children", ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags, true); + + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")), + SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, + "lldb.formatters.cpp.libcxx.stddeque_SynthProvider"))); + + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "shared_ptr synthetic children", ConstString("^(std::__1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); + + stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(false); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__1::map<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__1::deque<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_summary_flags); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__1::set<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__1::multiset<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__1::multimap<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::unordered containers summary provider", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_summary_flags, true); + + stl_summary_flags.SetSkipPointers(true); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::shared_ptr summary provider", ConstString("^std::__1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::weak_ptr summary provider", ConstString("^std::__1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true); + + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__1::__wrap_iter<.+>$"), stl_synth_flags, true); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__1::__map_iterator<.+>$"), stl_synth_flags, true); + + AddFilter(cpp_category_sp, {"__a_"}, "libc++ std::atomic filter", ConstString("^std::__1::atomic<.*>$"), stl_synth_flags, true); +#endif +} + +static void +LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) +{ + if (!cpp_category_sp) + return; + + TypeSummaryImpl::Flags stl_summary_flags; + stl_summary_flags.SetCascades(true) + .SetSkipPointers(false) + .SetSkipReferences(false) + .SetDontShowChildren(true) + .SetDontShowValue(true) + .SetShowMembersOneLiner(false) + .SetHideItemNames(false); + + lldb::TypeSummaryImplSP std_string_summary_sp(new StringSummaryFormat(stl_summary_flags, + "${var._M_dataplus._M_p}")); + + lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, + LibStdcppStringSummaryProvider, + "libstdc++ c++11 std::string summary provider")); + lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, + LibStdcppWStringSummaryProvider, + "libstdc++ c++11 std::wstring summary provider")); + + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"), + std_string_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char>"), + std_string_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"), + std_string_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), + std_string_summary_sp); + + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::string"), + cxx11_string_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >"), + cxx11_string_summary_sp); + + // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*) + lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags, + "${var._M_dataplus._M_p%S}")); + + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"), + std_wstring_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t>"), + std_wstring_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"), + std_wstring_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"), + std_wstring_summary_sp); + + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::wstring"), + cxx11_wstring_summary_sp); + cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"), + cxx11_wstring_summary_sp); + +#ifndef LLDB_DISABLE_PYTHON + + SyntheticChildren::Flags stl_synth_flags; + stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false); + + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")), + SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, + "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")), + SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, + "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider"))); + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")), + SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, + "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider"))); + stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true); + cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")), + TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, + "size=${svar%#}"))); + cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")), + TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, + "size=${svar%#}"))); + cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")), + TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, + "size=${svar%#}"))); + + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true); + + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true); +#endif +} + +static void +LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) +{ + if (!cpp_category_sp) + return; + + TypeSummaryImpl::Flags string_flags; + string_flags.SetCascades(true) + .SetSkipPointers(true) + .SetSkipReferences(false) + .SetDontShowChildren(true) + .SetDontShowValue(false) + .SetShowMembersOneLiner(false) + .SetHideItemNames(false); + + TypeSummaryImpl::Flags string_array_flags; + string_array_flags.SetCascades(true) + .SetSkipPointers(true) + .SetSkipReferences(false) + .SetDontShowChildren(true) + .SetDontShowValue(true) + .SetShowMembersOneLiner(false) + .SetHideItemNames(false); + +#ifndef LLDB_DISABLE_PYTHON + // FIXME because of a bug in the FormattersContainer we need to add a summary for both X* and const X* (<rdar://problem/12717717>) + AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::Char16StringSummaryProvider, + "char16_t [] summary provider", + ConstString("char16_t \\[[0-9]+\\]"), + string_array_flags, + true); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::Char32StringSummaryProvider, + "char32_t [] summary provider", + ConstString("char32_t \\[[0-9]+\\]"), + string_array_flags, + true); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags); + + TypeSummaryImpl::Flags widechar_flags; + widechar_flags.SetDontShowValue(true) + .SetSkipPointers(true) + .SetSkipReferences(false) + .SetCascades(true) + .SetDontShowChildren(true) + .SetHideItemNames(true) + .SetShowMembersOneLiner(false); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, "char16_t summary provider", ConstString("char16_t"), widechar_flags); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32SummaryProvider, "char32_t summary provider", ConstString("char32_t"), widechar_flags); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider, "wchar_t summary provider", ConstString("wchar_t"), widechar_flags); + + AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, "unichar summary provider", ConstString("unichar"), widechar_flags); +#endif +} + +lldb::TypeCategoryImplSP +CPlusPlusLanguage::GetFormatters () +{ + static std::once_flag g_initialize; + static TypeCategoryImplSP g_category; + + std::call_once(g_initialize, [this] () -> void { + DataVisualization::Categories::GetCategory(GetPluginName(), g_category); + if (g_category) + { + LoadLibCxxFormatters(g_category); + LoadLibStdcppFormatters(g_category); + LoadSystemFormatters(g_category); + } + }); + return g_category; +} + +HardcodedFormatters::HardcodedSummaryFinder +CPlusPlusLanguage::GetHardcodedSummaries () +{ + static std::once_flag g_initialize; + static ConstString g_vectortypes("VectorTypes"); + static HardcodedFormatters::HardcodedSummaryFinder g_formatters; + + std::call_once(g_initialize, [] () -> void { + g_formatters.push_back( + [](lldb_private::ValueObject& valobj, + lldb::DynamicValueType, + FormatManager&) -> TypeSummaryImpl::SharedPointer { + static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags(), lldb_private::formatters::CXXFunctionPointerSummaryProvider, "Function pointer summary provider")); + if (valobj.GetCompilerType().IsFunctionPointerType()) + { + return formatter_sp; + } + return nullptr; + }); + g_formatters.push_back( + [](lldb_private::ValueObject& valobj, + lldb::DynamicValueType, + FormatManager& fmt_mgr) -> TypeSummaryImpl::SharedPointer { + static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags() + .SetCascades(true) + .SetDontShowChildren(true) + .SetHideItemNames(true) + .SetShowMembersOneLiner(true) + .SetSkipPointers(true) + .SetSkipReferences(false), + lldb_private::formatters::VectorTypeSummaryProvider, + "vector_type pointer summary provider")); + if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) + { + if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) + return formatter_sp; + } + return nullptr; + }); + }); + + return g_formatters; +} + +HardcodedFormatters::HardcodedSyntheticFinder +CPlusPlusLanguage::GetHardcodedSynthetics () +{ + static std::once_flag g_initialize; + static ConstString g_vectortypes("VectorTypes"); + static HardcodedFormatters::HardcodedSyntheticFinder g_formatters; + + std::call_once(g_initialize, [] () -> void { + g_formatters.push_back( + [](lldb_private::ValueObject& valobj, + lldb::DynamicValueType, + FormatManager& fmt_mgr) -> SyntheticChildren::SharedPointer { + static CXXSyntheticChildren::SharedPointer formatter_sp(new CXXSyntheticChildren(SyntheticChildren::Flags().SetCascades(true).SetSkipPointers(true).SetSkipReferences(true).SetNonCacheable(true), + "vector_type synthetic children", + lldb_private::formatters::VectorTypeSyntheticFrontEndCreator)); + if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) + { + if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) + return formatter_sp; + } + return nullptr; + }); + }); + + return g_formatters; +} + diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h new file mode 100644 index 000000000000..1a8c0f6938a5 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h @@ -0,0 +1,186 @@ +//===-- CPlusPlusLanguage.h -------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_CPlusPlusLanguage_h_ +#define liblldb_CPlusPlusLanguage_h_ + +// C Includes +// C++ Includes +#include <vector> + +// Other libraries and framework includes +#include "llvm/ADT/StringRef.h" + +// Project includes +#include "lldb/lldb-private.h" +#include "lldb/Core/ConstString.h" +#include "lldb/Target/Language.h" + +namespace lldb_private { + +class CPlusPlusLanguage : + public Language +{ +public: + class MethodName + { + public: + enum Type + { + eTypeInvalid, + eTypeUnknownMethod, + eTypeClassMethod, + eTypeInstanceMethod + }; + + MethodName () : + m_full(), + m_basename(), + m_context(), + m_arguments(), + m_qualifiers(), + m_type (eTypeInvalid), + m_parsed (false), + m_parse_error (false) + { + } + + MethodName (const ConstString &s) : + m_full(s), + m_basename(), + m_context(), + m_arguments(), + m_qualifiers(), + m_type (eTypeInvalid), + m_parsed (false), + m_parse_error (false) + { + } + + void + Clear(); + + bool + IsValid () + { + if (!m_parsed) + Parse(); + if (m_parse_error) + return false; + if (m_type == eTypeInvalid) + return false; + return (bool)m_full; + } + + Type + GetType () const + { + return m_type; + } + + const ConstString & + GetFullName () const + { + return m_full; + } + + llvm::StringRef + GetBasename (); + + llvm::StringRef + GetContext (); + + llvm::StringRef + GetArguments (); + + llvm::StringRef + GetQualifiers (); + + protected: + void + Parse(); + + ConstString m_full; // Full name: "lldb::SBTarget::GetBreakpointAtIndex(unsigned int) const" + llvm::StringRef m_basename; // Basename: "GetBreakpointAtIndex" + llvm::StringRef m_context; // Decl context: "lldb::SBTarget" + llvm::StringRef m_arguments; // Arguments: "(unsigned int)" + llvm::StringRef m_qualifiers; // Qualifiers: "const" + Type m_type; + bool m_parsed; + bool m_parse_error; + }; + + CPlusPlusLanguage() = default; + + ~CPlusPlusLanguage() override = default; + + lldb::LanguageType + GetLanguageType () const override + { + return lldb::eLanguageTypeC_plus_plus; + } + + lldb::TypeCategoryImplSP + GetFormatters () override; + + HardcodedFormatters::HardcodedSummaryFinder + GetHardcodedSummaries () override; + + HardcodedFormatters::HardcodedSyntheticFinder + GetHardcodedSynthetics () override; + + //------------------------------------------------------------------ + // Static Functions + //------------------------------------------------------------------ + static void + Initialize(); + + static void + Terminate(); + + static lldb_private::Language * + CreateInstance (lldb::LanguageType language); + + static lldb_private::ConstString + GetPluginNameStatic(); + + static bool + IsCPPMangledName(const char *name); + + // Extract C++ context and identifier from a string using heuristic matching (as opposed to + // CPlusPlusLanguage::MethodName which has to have a fully qualified C++ name with parens and arguments. + // If the name is a lone C identifier (e.g. C) or a qualified C identifier (e.g. A::B::C) it will return true, + // and identifier will be the identifier (C and C respectively) and the context will be "" and "A::B::" respectively. + // If the name fails the heuristic matching for a qualified or unqualified C/C++ identifier, then it will return false + // and identifier and context will be unchanged. + + static bool + ExtractContextAndIdentifier (const char *name, llvm::StringRef &context, llvm::StringRef &identifier); + + // in some cases, compilers will output different names for one same type. when that happens, it might be impossible + // to construct SBType objects for a valid type, because the name that is available is not the same as the name that + // can be used as a search key in FindTypes(). the equivalents map here is meant to return possible alternative names + // for a type through which a search can be conducted. Currently, this is only enabled for C++ but can be extended + // to ObjC or other languages if necessary + static uint32_t + FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents); + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + ConstString + GetPluginName() override; + + uint32_t + GetPluginVersion() override; +}; + +} // namespace lldb_private + +#endif // liblldb_CPlusPlusLanguage_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp new file mode 100644 index 000000000000..7e8d9582a2b5 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp @@ -0,0 +1,204 @@ +//===-- CXXStringTypes.cpp --------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "CxxStringTypes.h" + +#include "llvm/Support/ConvertUTF.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/StringPrinter.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ProcessStructReader.h" +#include "lldb/DataFormatters/FormattersHelpers.h" + +#include <algorithm> + +#if __ANDROID_NDK__ +#include <sys/types.h> +#endif + +#include "lldb/Host/Time.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::Char16StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + lldb::addr_t valobj_addr = GetArrayAddressOrPointerValue(valobj); + if (valobj_addr == 0 || valobj_addr == LLDB_INVALID_ADDRESS) + return false; + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + options.SetLocation(valobj_addr); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetPrefixToken("u"); + + if (!StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options)) + { + stream.Printf("Summary Unavailable"); + return true; + } + + return true; +} + +bool +lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + lldb::addr_t valobj_addr = GetArrayAddressOrPointerValue(valobj); + if (valobj_addr == 0 || valobj_addr == LLDB_INVALID_ADDRESS) + return false; + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + options.SetLocation(valobj_addr); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetPrefixToken("U"); + + if (!StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF32>(options)) + { + stream.Printf("Summary Unavailable"); + return true; + } + + return true; +} + +bool +lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + lldb::addr_t valobj_addr = GetArrayAddressOrPointerValue(valobj); + if (valobj_addr == 0 || valobj_addr == LLDB_INVALID_ADDRESS) + return false; + + // Get a wchar_t basic type from the current type system + CompilerType wchar_compiler_type = valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar); + + if (!wchar_compiler_type) + return false; + + const uint32_t wchar_size = wchar_compiler_type.GetBitSize(nullptr); // Safe to pass NULL for exe_scope here + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + options.SetLocation(valobj_addr); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetPrefixToken("L"); + + switch (wchar_size) + { + case 8: + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(options); + case 16: + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); + case 32: + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF32>(options); + default: + stream.Printf("size for wchar_t is not valid"); + return true; + } + return true; +} + +bool +lldb_private::formatters::Char16SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&) +{ + DataExtractor data; + Error error; + valobj.GetData(data, error); + + if (error.Fail()) + return false; + + std::string value; + valobj.GetValueAsCString(lldb::eFormatUnicode16, value); + if (!value.empty()) + stream.Printf("%s ", value.c_str()); + + StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); + options.SetData(data); + options.SetStream(&stream); + options.SetPrefixToken("u"); + options.SetQuote('\''); + options.SetSourceSize(1); + options.SetBinaryZeroIsTerminator(false); + + return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); +} + +bool +lldb_private::formatters::Char32SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&) +{ + DataExtractor data; + Error error; + valobj.GetData(data, error); + + if (error.Fail()) + return false; + + std::string value; + valobj.GetValueAsCString(lldb::eFormatUnicode32, value); + if (!value.empty()) + stream.Printf("%s ", value.c_str()); + + StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); + options.SetData(data); + options.SetStream(&stream); + options.SetPrefixToken("U"); + options.SetQuote('\''); + options.SetSourceSize(1); + options.SetBinaryZeroIsTerminator(false); + + return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF32>(options); +} + +bool +lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&) +{ + DataExtractor data; + Error error; + valobj.GetData(data, error); + + if (error.Fail()) + return false; + + StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); + options.SetData(data); + options.SetStream(&stream); + options.SetPrefixToken("L"); + options.SetQuote('\''); + options.SetSourceSize(1); + options.SetBinaryZeroIsTerminator(false); + + return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.h b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.h new file mode 100644 index 000000000000..bfb03bda7ee0 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.h @@ -0,0 +1,41 @@ +//===-- CxxStringTypes.h ----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_CxxStringTypes_h_ +#define liblldb_CxxStringTypes_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" + +namespace lldb_private { + namespace formatters + { + bool + Char16StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // char16_t* and unichar* + + bool + Char32StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // char32_t* + + bool + WCharStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // wchar_t* + + bool + Char16SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // char16_t and unichar + + bool + Char32SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // char32_t + + bool + WCharSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // wchar_t + + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_CxxStringTypes_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp new file mode 100644 index 000000000000..950bd62c5c9f --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp @@ -0,0 +1,653 @@ +//===-- LibCxx.cpp ----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "LibCxx.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/FormatEntity.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/StringPrinter.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/VectorIterator.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::LibcxxSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); + if (!valobj_sp) + return false; + ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true)); + ValueObjectSP count_sp(valobj_sp->GetChildAtNamePath( {ConstString("__cntrl_"),ConstString("__shared_owners_")} )); + ValueObjectSP weakcount_sp(valobj_sp->GetChildAtNamePath( {ConstString("__cntrl_"),ConstString("__shared_weak_owners_")} )); + + if (!ptr_sp) + return false; + + if (ptr_sp->GetValueAsUnsigned(0) == 0) + { + stream.Printf("nullptr"); + return true; + } + else + { + bool print_pointee = false; + Error error; + ValueObjectSP pointee_sp = ptr_sp->Dereference(error); + if (pointee_sp && error.Success()) + { + if (pointee_sp->DumpPrintableRepresentation(stream, + ValueObject::eValueObjectRepresentationStyleSummary, + lldb::eFormatInvalid, + ValueObject::ePrintableRepresentationSpecialCasesDisable, + false)) + print_pointee = true; + } + if (!print_pointee) + stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0)); + } + + if (count_sp) + stream.Printf(" strong=%" PRIu64, 1+count_sp->GetValueAsUnsigned(0)); + + if (weakcount_sp) + stream.Printf(" weak=%" PRIu64, 1+weakcount_sp->GetValueAsUnsigned(0)); + + return true; +} + +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_bool_type(), +m_exe_ctx_ref(), +m_count(0), +m_base_data_address(0), +m_children() +{ + if (valobj_sp) + { + Update(); + m_bool_type = valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool); + } +} + +size_t +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::CalculateNumChildren () +{ + return m_count; +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + auto iter = m_children.find(idx), + end = m_children.end(); + if (iter != end) + return iter->second; + if (idx >= m_count) + return ValueObjectSP(); + if (m_base_data_address == 0 || m_count == 0) + return ValueObjectSP(); + if (!m_bool_type) + return ValueObjectSP(); + size_t byte_idx = (idx >> 3); // divide by 8 to get byte index + size_t bit_index = (idx & 7); // efficient idx % 8 for bit index + lldb::addr_t byte_location = m_base_data_address + byte_idx; + ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP()); + if (!process_sp) + return ValueObjectSP(); + uint8_t byte = 0; + uint8_t mask = 0; + Error err; + size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err); + if (err.Fail() || bytes_read == 0) + return ValueObjectSP(); + switch (bit_index) + { + case 0: + mask = 1; break; + case 1: + mask = 2; break; + case 2: + mask = 4; break; + case 3: + mask = 8; break; + case 4: + mask = 16; break; + case 5: + mask = 32; break; + case 6: + mask = 64; break; + case 7: + mask = 128; break; + default: + return ValueObjectSP(); + } + bool bit_set = ((byte & mask) != 0); + DataBufferSP buffer_sp(new DataBufferHeap(m_bool_type.GetByteSize(nullptr),0)); + if (bit_set && buffer_sp && buffer_sp->GetBytes()) + *(buffer_sp->GetBytes()) = 1; // regardless of endianness, anything non-zero is true + StreamString name; name.Printf("[%" PRIu64 "]", (uint64_t)idx); + ValueObjectSP retval_sp(CreateValueObjectFromData(name.GetData(), DataExtractor(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize()), m_exe_ctx_ref, m_bool_type)); + if (retval_sp) + m_children[idx] = retval_sp; + return retval_sp; +} + +/*(std::__1::vector<std::__1::allocator<bool> >) vBool = { + __begin_ = 0x00000001001000e0 + __size_ = 56 + __cap_alloc_ = { + std::__1::__libcpp_compressed_pair_imp<unsigned long, std::__1::allocator<unsigned long> > = { + __first_ = 1 + } + } + }*/ + +bool +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() +{ + m_children.clear(); + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName(ConstString("__size_"), true)); + if (!size_sp) + return false; + m_count = size_sp->GetValueAsUnsigned(0); + if (!m_count) + return true; + ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName(ConstString("__begin_"), true)); + if (!begin_sp) + { + m_count = 0; + return false; + } + m_base_data_address = begin_sp->GetValueAsUnsigned(0); + if (!m_base_data_address) + { + m_count = 0; + return false; + } + return false; +} + +bool +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (!m_count || !m_base_data_address) + return UINT32_MAX; + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd () +{} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp)); +} + +/* + (lldb) fr var ibeg --raw --ptr-depth 1 + (std::__1::__map_iterator<std::__1::__tree_iterator<std::__1::pair<int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::__tree_node<std::__1::pair<int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, void *> *, long> >) ibeg = { + __i_ = { + __ptr_ = 0x0000000100103870 { + std::__1::__tree_node_base<void *> = { + std::__1::__tree_end_node<std::__1::__tree_node_base<void *> *> = { + __left_ = 0x0000000000000000 + } + __right_ = 0x0000000000000000 + __parent_ = 0x00000001001038b0 + __is_black_ = true + } + __value_ = { + first = 0 + second = { std::string } + */ + +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_pair_ptr() +{ + if (valobj_sp) + Update(); +} + +bool +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() +{ + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + + TargetSP target_sp(valobj_sp->GetTargetSP()); + + if (!target_sp) + return false; + + if (!valobj_sp) + return false; + + // this must be a ValueObject* because it is a child of the ValueObject we are producing children for + // it if were a ValueObjectSP, we would end up with a loop (iterator -> synthetic -> child -> parent == iterator) + // and that would in turn leak memory by never allowing the ValueObjects to die and free their memory + m_pair_ptr = valobj_sp->GetValueForExpressionPath(".__i_.__ptr_->__value_", + NULL, + NULL, + NULL, + ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None), + NULL).get(); + + return false; +} + +size_t +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::CalculateNumChildren () +{ + return 2; +} + +lldb::ValueObjectSP +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (!m_pair_ptr) + return lldb::ValueObjectSP(); + return m_pair_ptr->GetChildAtIndex(idx, true); +} + +bool +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (name == ConstString("first")) + return 0; + if (name == ConstString("second")) + return 1; + return UINT32_MAX; +} + +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::~LibCxxMapIteratorSyntheticFrontEnd () +{ + // this will be deleted when its parent dies (since it's a child object) + //delete m_pair_ptr; +} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp)); +} + +/* + (lldb) fr var ibeg --raw --ptr-depth 1 -T + (std::__1::__wrap_iter<int *>) ibeg = { + (std::__1::__wrap_iter<int *>::iterator_type) __i = 0x00000001001037a0 { + (int) *__i = 1 + } + } +*/ + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + static ConstString g_item_name; + if (!g_item_name) + g_item_name.SetCString("__i"); + if (!valobj_sp) + return NULL; + return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name)); +} + +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_cntrl(NULL), +m_count_sp(), +m_weak_count_sp(), +m_ptr_size(0), +m_byte_order(lldb::eByteOrderInvalid) +{ + if (valobj_sp) + Update(); +} + +size_t +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::CalculateNumChildren () +{ + return (m_cntrl ? 1 : 0); +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (!m_cntrl) + return lldb::ValueObjectSP(); + + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return lldb::ValueObjectSP(); + + if (idx == 0) + return valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true); + + if (idx > 2) + return lldb::ValueObjectSP(); + + if (idx == 1) + { + if (!m_count_sp) + { + ValueObjectSP shared_owners_sp(m_cntrl->GetChildMemberWithName(ConstString("__shared_owners_"),true)); + if (!shared_owners_sp) + return lldb::ValueObjectSP(); + uint64_t count = 1 + shared_owners_sp->GetValueAsUnsigned(0); + DataExtractor data(&count, 8, m_byte_order, m_ptr_size); + m_count_sp = CreateValueObjectFromData("count", data, valobj_sp->GetExecutionContextRef(), shared_owners_sp->GetCompilerType()); + } + return m_count_sp; + } + else /* if (idx == 2) */ + { + if (!m_weak_count_sp) + { + ValueObjectSP shared_weak_owners_sp(m_cntrl->GetChildMemberWithName(ConstString("__shared_weak_owners_"),true)); + if (!shared_weak_owners_sp) + return lldb::ValueObjectSP(); + uint64_t count = 1 + shared_weak_owners_sp->GetValueAsUnsigned(0); + DataExtractor data(&count, 8, m_byte_order, m_ptr_size); + m_weak_count_sp = CreateValueObjectFromData("count", data, valobj_sp->GetExecutionContextRef(), shared_weak_owners_sp->GetCompilerType()); + } + return m_weak_count_sp; + } +} + +bool +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() +{ + m_count_sp.reset(); + m_weak_count_sp.reset(); + m_cntrl = NULL; + + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + + TargetSP target_sp(valobj_sp->GetTargetSP()); + if (!target_sp) + return false; + + m_byte_order = target_sp->GetArchitecture().GetByteOrder(); + m_ptr_size = target_sp->GetArchitecture().GetAddressByteSize(); + + lldb::ValueObjectSP cntrl_sp(valobj_sp->GetChildMemberWithName(ConstString("__cntrl_"),true)); + + m_cntrl = cntrl_sp.get(); // need to store the raw pointer to avoid a circular dependency + return false; +} + +bool +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (name == ConstString("__ptr_")) + return 0; + if (name == ConstString("count")) + return 1; + if (name == ConstString("weak_count")) + return 2; + return UINT32_MAX; +} + +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd () +{} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp)); +} + +bool +lldb_private::formatters::LibcxxContainerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + if (valobj.IsPointerType()) + { + uint64_t value = valobj.GetValueAsUnsigned(0); + if (!value) + return false; + stream.Printf("0x%016" PRIx64 " ", value); + } + return FormatEntity::FormatStringRef("size=${svar%#}", stream, NULL, NULL, NULL, &valobj, false, false); +} + +// the field layout in a libc++ string (cap, side, data or data, size, cap) +enum LibcxxStringLayoutMode +{ + eLibcxxStringLayoutModeCSD = 0, + eLibcxxStringLayoutModeDSC = 1, + eLibcxxStringLayoutModeInvalid = 0xffff +}; + +// this function abstracts away the layout and mode details of a libc++ string +// and returns the address of the data and the size ready for callers to consume +static bool +ExtractLibcxxStringInfo (ValueObject& valobj, + ValueObjectSP &location_sp, + uint64_t& size) +{ + ValueObjectSP D(valobj.GetChildAtIndexPath({0,0,0,0})); + if (!D) + return false; + + ValueObjectSP layout_decider(D->GetChildAtIndexPath({0,0})); + + // this child should exist + if (!layout_decider) + return false; + + ConstString g_data_name("__data_"); + ConstString g_size_name("__size_"); + bool short_mode = false; // this means the string is in short-mode and the data is stored inline + LibcxxStringLayoutMode layout = (layout_decider->GetName() == g_data_name) ? eLibcxxStringLayoutModeDSC : eLibcxxStringLayoutModeCSD; + uint64_t size_mode_value = 0; + + if (layout == eLibcxxStringLayoutModeDSC) + { + ValueObjectSP size_mode(D->GetChildAtIndexPath({1,1,0})); + if (!size_mode) + return false; + + if (size_mode->GetName() != g_size_name) + { + // we are hitting the padding structure, move along + size_mode = D->GetChildAtIndexPath({1,1,1}); + if (!size_mode) + return false; + } + + size_mode_value = (size_mode->GetValueAsUnsigned(0)); + short_mode = ((size_mode_value & 0x80) == 0); + } + else + { + ValueObjectSP size_mode(D->GetChildAtIndexPath({1,0,0})); + if (!size_mode) + return false; + + size_mode_value = (size_mode->GetValueAsUnsigned(0)); + short_mode = ((size_mode_value & 1) == 0); + } + + if (short_mode) + { + ValueObjectSP s(D->GetChildAtIndex(1, true)); + if (!s) + return false; + location_sp = s->GetChildAtIndex((layout == eLibcxxStringLayoutModeDSC) ? 0 : 1, true); + size = (layout == eLibcxxStringLayoutModeDSC) ? size_mode_value : ((size_mode_value >> 1) % 256); + return (location_sp.get() != nullptr); + } + else + { + ValueObjectSP l(D->GetChildAtIndex(0, true)); + if (!l) + return false; + // we can use the layout_decider object as the data pointer + location_sp = (layout == eLibcxxStringLayoutModeDSC) ? layout_decider : l->GetChildAtIndex(2, true); + ValueObjectSP size_vo(l->GetChildAtIndex(1, true)); + if (!size_vo || !location_sp) + return false; + size = size_vo->GetValueAsUnsigned(0); + return true; + } +} + +bool +lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options) +{ + uint64_t size = 0; + ValueObjectSP location_sp((ValueObject*)nullptr); + if (!ExtractLibcxxStringInfo(valobj, location_sp, size)) + return false; + if (size == 0) + { + stream.Printf("L\"\""); + return true; + } + if (!location_sp) + return false; + + DataExtractor extractor; + + StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); + + if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped) + { + const auto max_size = valobj.GetTargetSP()->GetMaximumSizeOfStringSummary(); + if (size > max_size) + { + size = max_size; + options.SetIsTruncated(true); + } + } + location_sp->GetPointeeData(extractor, 0, size); + + // std::wstring::size() is measured in 'characters', not bytes + auto wchar_t_size = valobj.GetTargetSP()->GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeWChar).GetByteSize(nullptr); + + options.SetData(extractor); + options.SetStream(&stream); + options.SetPrefixToken("L"); + options.SetQuote('"'); + options.SetSourceSize(size); + options.SetBinaryZeroIsTerminator(false); + + switch (wchar_t_size) + { + case 1: + StringPrinter::ReadBufferAndDumpToStream<lldb_private::formatters::StringPrinter::StringElementType::UTF8>(options); + break; + + case 2: + lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStream<lldb_private::formatters::StringPrinter::StringElementType::UTF16>(options); + break; + + case 4: + lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStream<lldb_private::formatters::StringPrinter::StringElementType::UTF32>(options); + break; + + default: + stream.Printf("size for wchar_t is not valid"); + return true; + } + + return true; +} + +bool +lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options) +{ + uint64_t size = 0; + ValueObjectSP location_sp((ValueObject*)nullptr); + + if (!ExtractLibcxxStringInfo(valobj, location_sp, size)) + return false; + + if (size == 0) + { + stream.Printf("\"\""); + return true; + } + + if (!location_sp) + return false; + + StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); + + DataExtractor extractor; + if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped) + { + const auto max_size = valobj.GetTargetSP()->GetMaximumSizeOfStringSummary(); + if (size > max_size) + { + size = max_size; + options.SetIsTruncated(true); + } + } + location_sp->GetPointeeData(extractor, 0, size); + + options.SetData(extractor); + options.SetStream(&stream); + options.SetPrefixToken(0); + options.SetQuote('"'); + options.SetSourceSize(size); + options.SetBinaryZeroIsTerminator(false); + StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::ASCII>(options); + + return true; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h new file mode 100644 index 000000000000..ae00bc0ade34 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h @@ -0,0 +1,141 @@ +//===-- LibCxx.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_LibCxx_h_ +#define liblldb_LibCxx_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +namespace lldb_private { + namespace formatters + { + + bool + LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libc++ std::string + + bool + LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libc++ std::wstring + + bool + LibcxxSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libc++ std::shared_ptr<> and std::weak_ptr<> + + class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + ~LibcxxVectorBoolSyntheticFrontEnd() override; + + private: + CompilerType m_bool_type; + ExecutionContextRef m_exe_ctx_ref; + uint64_t m_count; + lldb::addr_t m_base_data_address; + std::map<size_t,lldb::ValueObjectSP> m_children; + }; + + SyntheticChildrenFrontEnd* LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + bool + LibcxxContainerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + class LibCxxMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + ~LibCxxMapIteratorSyntheticFrontEnd() override; + + private: + ValueObject *m_pair_ptr; + }; + + SyntheticChildrenFrontEnd* LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + class LibcxxSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + ~LibcxxSharedPtrSyntheticFrontEnd() override; + + private: + ValueObject* m_cntrl; + lldb::ValueObjectSP m_count_sp; + lldb::ValueObjectSP m_weak_count_sp; + uint8_t m_ptr_size; + lldb::ByteOrder m_byte_order; + }; + + SyntheticChildrenFrontEnd* LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibcxxInitializerListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_LibCxx_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp new file mode 100644 index 000000000000..9970d49dac62 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp @@ -0,0 +1,147 @@ +//===-- LibCxxInitializerList.cpp -------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "LibCxx.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/FormattersHelpers.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace lldb_private { + namespace formatters { + class LibcxxInitializerListSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~LibcxxInitializerListSyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + ValueObject* m_start; + CompilerType m_element_type; + uint32_t m_element_size; + size_t m_num_elements; + std::map<size_t,lldb::ValueObjectSP> m_children; + }; + } // namespace formatters +} // namespace lldb_private + +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_start(NULL), +m_element_type(), +m_element_size(0), +m_num_elements(0), +m_children() +{ + if (valobj_sp) + Update(); +} + +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::~LibcxxInitializerListSyntheticFrontEnd() +{ + // this needs to stay around because it's a child object who will follow its parent's life cycle + // delete m_start; +} + +size_t +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::CalculateNumChildren () +{ + static ConstString g___size_("__size_"); + m_num_elements = 0; + ValueObjectSP size_sp(m_backend.GetChildMemberWithName(g___size_, true)); + if (size_sp) + m_num_elements = size_sp->GetValueAsUnsigned(0); + return m_num_elements; +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (!m_start) + return lldb::ValueObjectSP(); + + auto cached = m_children.find(idx); + if (cached != m_children.end()) + return cached->second; + + uint64_t offset = idx * m_element_size; + offset = offset + m_start->GetValueAsUnsigned(0); + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + ValueObjectSP child_sp = CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type); + m_children[idx] = child_sp; + return child_sp; +} + +bool +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::Update() +{ + static ConstString g___begin_("__begin_"); + + m_start = nullptr; + m_num_elements = 0; + m_children.clear(); + lldb::TemplateArgumentKind kind; + m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind); + if (kind != lldb::eTemplateArgumentKindType || false == m_element_type.IsValid()) + return false; + + m_element_size = m_element_type.GetByteSize(nullptr); + + if (m_element_size > 0) + m_start = m_backend.GetChildMemberWithName(g___begin_,true).get(); // store raw pointers or end up with a circular dependency + + return false; +} + +bool +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (!m_start) + return UINT32_MAX; + return ExtractIndexFromString(name.GetCString()); +} + +lldb_private::SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxInitializerListSyntheticFrontEnd(valobj_sp)); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp new file mode 100644 index 000000000000..f86f968ea857 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp @@ -0,0 +1,414 @@ +//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "LibCxx.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace { + + class ListEntry + { + public: + ListEntry() = default; + ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} + ListEntry (const ListEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {} + ListEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {} + + ListEntry + next () + { + if (!m_entry_sp) + return ListEntry(); + return ListEntry(m_entry_sp->GetChildAtIndexPath({0,1})); + } + + ListEntry + prev () + { + if (!m_entry_sp) + return ListEntry(); + return ListEntry(m_entry_sp->GetChildAtIndexPath({0,0})); + } + + uint64_t + value () const + { + if (!m_entry_sp) + return 0; + return m_entry_sp->GetValueAsUnsigned(0); + } + + bool + null() + { + return (value() == 0); + } + + explicit operator bool () + { + return GetEntry().get() != nullptr && null() == false; + } + + ValueObjectSP + GetEntry () + { + return m_entry_sp; + } + + void + SetEntry (ValueObjectSP entry) + { + m_entry_sp = entry; + } + + bool + operator == (const ListEntry& rhs) const + { + return value() == rhs.value(); + } + + bool + operator != (const ListEntry& rhs) const + { + return !(*this == rhs); + } + + private: + ValueObjectSP m_entry_sp; + }; + + class ListIterator + { + public: + ListIterator() = default; + ListIterator (ListEntry entry) : m_entry(entry) {} + ListIterator (ValueObjectSP entry) : m_entry(entry) {} + ListIterator (const ListIterator& rhs) : m_entry(rhs.m_entry) {} + ListIterator (ValueObject* entry) : m_entry(entry) {} + + ValueObjectSP + value () + { + return m_entry.GetEntry(); + } + + ValueObjectSP + advance (size_t count) + { + if (count == 0) + return m_entry.GetEntry(); + if (count == 1) + { + next (); + return m_entry.GetEntry(); + } + while (count > 0) + { + next (); + count--; + if (m_entry.null()) + return lldb::ValueObjectSP(); + } + return m_entry.GetEntry(); + } + + bool + operator == (const ListIterator& rhs) const + { + return (rhs.m_entry == m_entry); + } + + protected: + void + next () + { + m_entry = m_entry.next(); + } + + void + prev () + { + m_entry = m_entry.prev(); + } + + private: + ListEntry m_entry; + }; + +} // end anonymous namespace + +namespace lldb_private { + namespace formatters { + class LibcxxStdListSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~LibcxxStdListSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + bool + HasLoop(size_t count); + + size_t m_list_capping_size; + static const bool g_use_loop_detect = true; + + size_t m_loop_detected; // The number of elements that have had loop detection run over them. + ListEntry m_slow_runner; // Used for loop detection + ListEntry m_fast_runner; // Used for loop detection + + lldb::addr_t m_node_address; + ValueObject* m_head; + ValueObject* m_tail; + CompilerType m_element_type; + size_t m_count; + std::map<size_t,lldb::ValueObjectSP> m_children; + std::map<size_t, ListIterator> m_iterators; + }; + } // namespace formatters +} // namespace lldb_private + +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_list_capping_size(0), +m_loop_detected(0), +m_node_address(), +m_head(NULL), +m_tail(NULL), +m_element_type(), +m_count(UINT32_MAX), +m_children(), +m_iterators() +{ + if (valobj_sp) + Update(); +} + +bool +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop(size_t count) +{ + if (g_use_loop_detect == false) + return false; + // don't bother checking for a loop if we won't actually need to jump nodes + if (m_count < 2) + return false; + + if (m_loop_detected == 0) + { + // This is the first time we are being run (after the last update). Set up the loop + // invariant for the first element. + m_slow_runner = ListEntry(m_head).next(); + m_fast_runner = m_slow_runner.next(); + m_loop_detected = 1; + } + + // Loop invariant: + // Loop detection has been run over the first m_loop_detected elements. If m_slow_runner == + // m_fast_runner then the loop has been detected after m_loop_detected elements. + const size_t steps_to_run = std::min(count,m_count); + while (m_loop_detected < steps_to_run + && m_slow_runner + && m_fast_runner + && m_slow_runner != m_fast_runner) { + + m_slow_runner = m_slow_runner.next(); + m_fast_runner = m_fast_runner.next().next(); + m_loop_detected++; + } + if (count <= m_loop_detected) + return false; // No loop in the first m_loop_detected elements. + if (!m_slow_runner || !m_fast_runner) + return false; // Reached the end of the list. Definitely no loops. + return m_slow_runner == m_fast_runner; +} + +size_t +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::CalculateNumChildren () +{ + if (m_count != UINT32_MAX) + return m_count; + if (!m_head || !m_tail || m_node_address == 0) + return 0; + ValueObjectSP size_alloc(m_backend.GetChildMemberWithName(ConstString("__size_alloc_"), true)); + if (size_alloc) + { + ValueObjectSP first(size_alloc->GetChildMemberWithName(ConstString("__first_"), true)); + if (first) + { + m_count = first->GetValueAsUnsigned(UINT32_MAX); + } + } + if (m_count != UINT32_MAX) + { + return m_count; + } + else + { + uint64_t next_val = m_head->GetValueAsUnsigned(0); + uint64_t prev_val = m_tail->GetValueAsUnsigned(0); + if (next_val == 0 || prev_val == 0) + return 0; + if (next_val == m_node_address) + return 0; + if (next_val == prev_val) + return 1; + uint64_t size = 2; + ListEntry current(m_head); + while (current.next() && current.next().value() != m_node_address) + { + size++; + current = current.next(); + if (size > m_list_capping_size) + break; + } + return m_count = (size-1); + } +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + + if (!m_head || !m_tail || m_node_address == 0) + return lldb::ValueObjectSP(); + + auto cached = m_children.find(idx); + if (cached != m_children.end()) + return cached->second; + + if (HasLoop(idx+1)) + return lldb::ValueObjectSP(); + + size_t actual_advance = idx; + + ListIterator current(m_head); + if (idx > 0) + { + auto cached_iterator = m_iterators.find(idx-1); + if (cached_iterator != m_iterators.end()) + { + current = cached_iterator->second; + actual_advance = 1; + } + } + + ValueObjectSP current_sp(current.advance(actual_advance)); + if (!current_sp) + return lldb::ValueObjectSP(); + + m_iterators[idx] = current; + + current_sp = current_sp->GetChildAtIndex(1, true); // get the __value_ child + if (!current_sp) + return lldb::ValueObjectSP(); + // we need to copy current_sp into a new object otherwise we will end up with all items named __value_ + DataExtractor data; + Error error; + current_sp->GetData(data, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + return (m_children[idx] = CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type)); +} + +bool +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() +{ + m_children.clear(); + m_iterators.clear(); + m_head = m_tail = NULL; + m_node_address = 0; + m_count = UINT32_MAX; + m_loop_detected = 0; + m_slow_runner.SetEntry(nullptr); + m_fast_runner.SetEntry(nullptr); + + Error err; + ValueObjectSP backend_addr(m_backend.AddressOf(err)); + m_list_capping_size = 0; + if (m_backend.GetTargetSP()) + m_list_capping_size = m_backend.GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); + if (m_list_capping_size == 0) + m_list_capping_size = 255; + if (err.Fail() || backend_addr.get() == NULL) + return false; + m_node_address = backend_addr->GetValueAsUnsigned(0); + if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS) + return false; + ValueObjectSP impl_sp(m_backend.GetChildMemberWithName(ConstString("__end_"),true)); + if (!impl_sp) + return false; + CompilerType list_type = m_backend.GetCompilerType(); + if (list_type.IsReferenceType()) + list_type = list_type.GetNonReferenceType(); + + if (list_type.GetNumTemplateArguments() == 0) + return false; + lldb::TemplateArgumentKind kind; + m_element_type = list_type.GetTemplateArgument(0, kind); + m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get(); + m_tail = impl_sp->GetChildMemberWithName(ConstString("__prev_"), true).get(); + return false; +} + +bool +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + return ExtractIndexFromString(name.GetCString()); +} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxStdListSyntheticFrontEnd(valobj_sp)); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp new file mode 100644 index 000000000000..aa82557edb02 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp @@ -0,0 +1,478 @@ +//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "LibCxx.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +class MapEntry +{ +public: + MapEntry() = default; + explicit MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} + MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {} + explicit MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {} + + ValueObjectSP + left () const + { + static ConstString g_left("__left_"); + if (!m_entry_sp) + return m_entry_sp; + return m_entry_sp->GetChildMemberWithName(g_left, true); + } + + ValueObjectSP + right () const + { + static ConstString g_right("__right_"); + if (!m_entry_sp) + return m_entry_sp; + return m_entry_sp->GetChildMemberWithName(g_right, true); + } + + ValueObjectSP + parent () const + { + static ConstString g_parent("__parent_"); + if (!m_entry_sp) + return m_entry_sp; + return m_entry_sp->GetChildMemberWithName(g_parent, true); + } + + uint64_t + value () const + { + if (!m_entry_sp) + return 0; + return m_entry_sp->GetValueAsUnsigned(0); + } + + bool + error () const + { + if (!m_entry_sp) + return true; + return m_entry_sp->GetError().Fail(); + } + + bool + null() const + { + return (value() == 0); + } + + ValueObjectSP + GetEntry () const + { + return m_entry_sp; + } + + void + SetEntry (ValueObjectSP entry) + { + m_entry_sp = entry; + } + + bool + operator == (const MapEntry& rhs) const + { + return (rhs.m_entry_sp.get() == m_entry_sp.get()); + } + +private: + ValueObjectSP m_entry_sp; +}; + +class MapIterator +{ +public: + MapIterator() = default; + MapIterator (MapEntry entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {} + MapIterator (ValueObjectSP entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {} + MapIterator (const MapIterator& rhs) : m_entry(rhs.m_entry),m_max_depth(rhs.m_max_depth), m_error(false) {} + MapIterator (ValueObject* entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {} + + ValueObjectSP + value () + { + return m_entry.GetEntry(); + } + + ValueObjectSP + advance (size_t count) + { + ValueObjectSP fail(nullptr); + if (m_error) + return fail; + size_t steps = 0; + while (count > 0) + { + next(); + count--, steps++; + if (m_error || + m_entry.null() || + (steps > m_max_depth)) + return fail; + } + return m_entry.GetEntry(); + } + +protected: + void + next () + { + if (m_entry.null()) + return; + MapEntry right(m_entry.right()); + if (right.null() == false) + { + m_entry = tree_min(std::move(right)); + return; + } + size_t steps = 0; + while (!is_left_child(m_entry)) + { + if (m_entry.error()) + { + m_error = true; + return; + } + m_entry.SetEntry(m_entry.parent()); + steps++; + if (steps > m_max_depth) + { + m_entry = MapEntry(); + return; + } + } + m_entry = MapEntry(m_entry.parent()); + } + +private: + MapEntry + tree_min (MapEntry&& x) + { + if (x.null()) + return MapEntry(); + MapEntry left(x.left()); + size_t steps = 0; + while (left.null() == false) + { + if (left.error()) + { + m_error = true; + return MapEntry(); + } + x = left; + left.SetEntry(x.left()); + steps++; + if (steps > m_max_depth) + return MapEntry(); + } + return x; + } + + bool + is_left_child (const MapEntry& x) + { + if (x.null()) + return false; + MapEntry rhs(x.parent()); + rhs.SetEntry(rhs.left()); + return x.value() == rhs.value(); + } + + MapEntry m_entry; + size_t m_max_depth; + bool m_error; +}; + +namespace lldb_private { + namespace formatters { + class LibcxxStdMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~LibcxxStdMapSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + bool + GetDataType(); + + void + GetValueOffset (const lldb::ValueObjectSP& node); + + ValueObject* m_tree; + ValueObject* m_root_node; + CompilerType m_element_type; + uint32_t m_skip_size; + size_t m_count; + std::map<size_t, lldb::ValueObjectSP> m_children; + std::map<size_t, MapIterator> m_iterators; + }; + } // namespace formatters +} // namespace lldb_private + +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_tree(NULL), +m_root_node(NULL), +m_element_type(), +m_skip_size(UINT32_MAX), +m_count(UINT32_MAX), +m_children(), +m_iterators() +{ + if (valobj_sp) + Update(); +} + +size_t +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::CalculateNumChildren () +{ + static ConstString g___pair3_("__pair3_"); + static ConstString g___first_("__first_"); + + if (m_count != UINT32_MAX) + return m_count; + if (m_tree == NULL) + return 0; + ValueObjectSP m_item(m_tree->GetChildMemberWithName(g___pair3_, true)); + if (!m_item) + return 0; + m_item = m_item->GetChildMemberWithName(g___first_, true); + if (!m_item) + return 0; + m_count = m_item->GetValueAsUnsigned(0); + return m_count; +} + +bool +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() +{ + static ConstString g___value_("__value_"); + + if (m_element_type.GetOpaqueQualType() && m_element_type.GetTypeSystem()) + return true; + m_element_type.Clear(); + ValueObjectSP deref; + Error error; + deref = m_root_node->Dereference(error); + if (!deref || error.Fail()) + return false; + deref = deref->GetChildMemberWithName(g___value_, true); + if (!deref) + return false; + m_element_type = deref->GetCompilerType(); + return true; +} + +void +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset (const lldb::ValueObjectSP& node) +{ + if (m_skip_size != UINT32_MAX) + return; + if (!node) + return; + CompilerType node_type(node->GetCompilerType()); + uint64_t bit_offset; + if (node_type.GetIndexOfFieldWithName("__value_", NULL, &bit_offset) == UINT32_MAX) + return; + m_skip_size = bit_offset / 8u; +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + static ConstString g___cc("__cc"); + static ConstString g___nc("__nc"); + static ConstString g___value_("__value_"); + + + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + if (m_tree == NULL || m_root_node == NULL) + return lldb::ValueObjectSP(); + + auto cached = m_children.find(idx); + if (cached != m_children.end()) + return cached->second; + + MapIterator iterator(m_root_node, CalculateNumChildren()); + + const bool need_to_skip = (idx > 0); + size_t actual_advancde = idx; + if (need_to_skip) + { + auto cached_iterator = m_iterators.find(idx-1); + if (cached_iterator != m_iterators.end()) + { + iterator = cached_iterator->second; + actual_advancde = 1; + } + } + + ValueObjectSP iterated_sp(iterator.advance(actual_advancde)); + if (iterated_sp.get() == NULL) + { + // this tree is garbage - stop + m_tree = NULL; // this will stop all future searches until an Update() happens + return iterated_sp; + } + if (GetDataType()) + { + if (!need_to_skip) + { + Error error; + iterated_sp = iterated_sp->Dereference(error); + if (!iterated_sp || error.Fail()) + { + m_tree = NULL; + return lldb::ValueObjectSP(); + } + GetValueOffset(iterated_sp); + iterated_sp = iterated_sp->GetChildMemberWithName(g___value_, true); + if (!iterated_sp) + { + m_tree = NULL; + return lldb::ValueObjectSP(); + } + } + else + { + // because of the way our debug info is made, we need to read item 0 first + // so that we can cache information used to generate other elements + if (m_skip_size == UINT32_MAX) + GetChildAtIndex(0); + if (m_skip_size == UINT32_MAX) + { + m_tree = NULL; + return lldb::ValueObjectSP(); + } + iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true); + if (!iterated_sp) + { + m_tree = NULL; + return lldb::ValueObjectSP(); + } + } + } + else + { + m_tree = NULL; + return lldb::ValueObjectSP(); + } + // at this point we have a valid + // we need to copy current_sp into a new object otherwise we will end up with all items named __value_ + DataExtractor data; + Error error; + iterated_sp->GetData(data, error); + if (error.Fail()) + { + m_tree = NULL; + return lldb::ValueObjectSP(); + } + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + auto potential_child_sp = CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type); + if (potential_child_sp) + { + switch (potential_child_sp->GetNumChildren()) + { + case 1: + { + auto child0_sp = potential_child_sp->GetChildAtIndex(0, true); + if (child0_sp && child0_sp->GetName() == g___cc) + potential_child_sp = child0_sp; + break; + } + case 2: + { + auto child0_sp = potential_child_sp->GetChildAtIndex(0, true); + auto child1_sp = potential_child_sp->GetChildAtIndex(1, true); + if (child0_sp && child0_sp->GetName() == g___cc && + child1_sp && child1_sp->GetName() == g___nc) + potential_child_sp = child0_sp; + break; + } + } + potential_child_sp->SetName(ConstString(name.GetData())); + } + m_iterators[idx] = iterator; + return (m_children[idx] = potential_child_sp); +} + +bool +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() +{ + static ConstString g___tree_("__tree_"); + static ConstString g___begin_node_("__begin_node_"); + m_count = UINT32_MAX; + m_tree = m_root_node = NULL; + m_children.clear(); + m_iterators.clear(); + m_tree = m_backend.GetChildMemberWithName(g___tree_, true).get(); + if (!m_tree) + return false; + m_root_node = m_tree->GetChildMemberWithName(g___begin_node_, true).get(); + return false; +} + +bool +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + return ExtractIndexFromString(name.GetCString()); +} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxStdMapSyntheticFrontEnd(valobj_sp)); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp new file mode 100644 index 000000000000..8ad806d52bce --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp @@ -0,0 +1,172 @@ +//===-- LibCxxUnorderedMap.cpp ----------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "LibCxx.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace lldb_private { + namespace formatters { + class LibcxxStdUnorderedMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~LibcxxStdUnorderedMapSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + ValueObject* m_tree; + size_t m_num_elements; + ValueObject* m_next_element; + std::map<size_t,lldb::ValueObjectSP> m_children; + std::vector<std::pair<ValueObject*, uint64_t> > m_elements_cache; + }; + } // namespace formatters +} // namespace lldb_private + +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_tree(NULL), +m_num_elements(0), +m_next_element(nullptr), +m_children(), +m_elements_cache() +{ + if (valobj_sp) + Update(); +} + +size_t +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::CalculateNumChildren () +{ + if (m_num_elements != UINT32_MAX) + return m_num_elements; + return 0; +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + if (m_tree == NULL) + return lldb::ValueObjectSP(); + + auto cached = m_children.find(idx); + if (cached != m_children.end()) + return cached->second; + + while (idx >= m_elements_cache.size()) + { + if (m_next_element == nullptr) + return lldb::ValueObjectSP(); + + Error error; + ValueObjectSP node_sp = m_next_element->Dereference(error); + if (!node_sp || error.Fail()) + return lldb::ValueObjectSP(); + + ValueObjectSP value_sp = node_sp->GetChildMemberWithName(ConstString("__value_"), true); + ValueObjectSP hash_sp = node_sp->GetChildMemberWithName(ConstString("__hash_"), true); + if (!hash_sp || !value_sp) + return lldb::ValueObjectSP(); + m_elements_cache.push_back({value_sp.get(),hash_sp->GetValueAsUnsigned(0)}); + m_next_element = node_sp->GetChildMemberWithName(ConstString("__next_"),true).get(); + if (!m_next_element || m_next_element->GetValueAsUnsigned(0) == 0) + m_next_element = nullptr; + } + + std::pair<ValueObject*, uint64_t> val_hash = m_elements_cache[idx]; + if (!val_hash.first) + return lldb::ValueObjectSP(); + StreamString stream; + stream.Printf("[%" PRIu64 "]", (uint64_t)idx); + DataExtractor data; + Error error; + val_hash.first->GetData(data, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + const bool thread_and_frame_only_if_stopped = true; + ExecutionContext exe_ctx = val_hash.first->GetExecutionContextRef().Lock(thread_and_frame_only_if_stopped); + return val_hash.first->CreateValueObjectFromData(stream.GetData(), + data, + exe_ctx, + val_hash.first->GetCompilerType()); +} + +bool +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::Update() +{ + m_num_elements = UINT32_MAX; + m_next_element = nullptr; + m_elements_cache.clear(); + m_children.clear(); + ValueObjectSP table_sp = m_backend.GetChildMemberWithName(ConstString("__table_"), true); + if (!table_sp) + return false; + ValueObjectSP num_elements_sp = table_sp->GetChildAtNamePath({ConstString("__p2_"),ConstString("__first_")}); + if (!num_elements_sp) + return false; + m_num_elements = num_elements_sp->GetValueAsUnsigned(0); + m_tree = table_sp->GetChildAtNamePath({ConstString("__p1_"),ConstString("__first_"),ConstString("__next_")}).get(); + if (m_num_elements > 0) + m_next_element = table_sp->GetChildAtNamePath({ConstString("__p1_"),ConstString("__first_"),ConstString("__next_")}).get(); + return false; +} + +bool +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + return ExtractIndexFromString(name.GetCString()); +} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp)); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp new file mode 100644 index 000000000000..9fb4f48e9090 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp @@ -0,0 +1,159 @@ +//===-- LibCxxVector.cpp ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "LibCxx.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/FormattersHelpers.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace lldb_private { + namespace formatters { + class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~LibcxxStdVectorSyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + ValueObject* m_start; + ValueObject* m_finish; + CompilerType m_element_type; + uint32_t m_element_size; + std::map<size_t,lldb::ValueObjectSP> m_children; + }; + } // namespace formatters +} // namespace lldb_private + +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_start(NULL), +m_finish(NULL), +m_element_type(), +m_element_size(0), +m_children() +{ + if (valobj_sp) + Update(); +} + +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::~LibcxxStdVectorSyntheticFrontEnd() +{ + // these need to stay around because they are child objects who will follow their parent's life cycle + // delete m_start; + // delete m_finish; +} + +size_t +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::CalculateNumChildren () +{ + if (!m_start || !m_finish) + return 0; + uint64_t start_val = m_start->GetValueAsUnsigned(0); + uint64_t finish_val = m_finish->GetValueAsUnsigned(0); + + if (start_val == 0 || finish_val == 0) + return 0; + + if (start_val >= finish_val) + return 0; + + size_t num_children = (finish_val - start_val); + if (num_children % m_element_size) + return 0; + return num_children/m_element_size; +} + +lldb::ValueObjectSP +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (!m_start || !m_finish) + return lldb::ValueObjectSP(); + + auto cached = m_children.find(idx); + if (cached != m_children.end()) + return cached->second; + + uint64_t offset = idx * m_element_size; + offset = offset + m_start->GetValueAsUnsigned(0); + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + ValueObjectSP child_sp = CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type); + m_children[idx] = child_sp; + return child_sp; +} + +bool +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() +{ + m_start = m_finish = NULL; + m_children.clear(); + ValueObjectSP data_type_finder_sp(m_backend.GetChildMemberWithName(ConstString("__end_cap_"),true)); + if (!data_type_finder_sp) + return false; + data_type_finder_sp = data_type_finder_sp->GetChildMemberWithName(ConstString("__first_"),true); + if (!data_type_finder_sp) + return false; + m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType(); + m_element_size = m_element_type.GetByteSize(nullptr); + + if (m_element_size > 0) + { + // store raw pointers or end up with a circular dependency + m_start = m_backend.GetChildMemberWithName(ConstString("__begin_"),true).get(); + m_finish = m_backend.GetChildMemberWithName(ConstString("__end_"),true).get(); + } + return false; +} + +bool +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (!m_start || !m_finish) + return UINT32_MAX; + return ExtractIndexFromString(name.GetCString()); +} + +lldb_private::SyntheticChildrenFrontEnd* +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibcxxStdVectorSyntheticFrontEnd(valobj_sp)); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp new file mode 100644 index 000000000000..ed89c5c84ea3 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp @@ -0,0 +1,373 @@ +//===-- LibStdcpp.cpp ---------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "LibStdcpp.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/StringPrinter.h" +#include "lldb/DataFormatters/VectorIterator.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName (const ConstString &name) override; + + ~LibstdcppMapIteratorSyntheticFrontEnd() override; + +private: + ExecutionContextRef m_exe_ctx_ref; + lldb::addr_t m_pair_address; + CompilerType m_pair_type; + EvaluateExpressionOptions m_options; + lldb::ValueObjectSP m_pair_sp; +}; + +/* + (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ibeg = { + (_Base_ptr) _M_node = 0x0000000100103910 { + (std::_Rb_tree_color) _M_color = _S_black + (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0 + (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000 + (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000 + } + } + */ + +LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd(*valobj_sp.get()), + m_exe_ctx_ref(), + m_pair_address(0), + m_pair_type(), + m_options(), + m_pair_sp() +{ + if (valobj_sp) + Update(); + m_options.SetCoerceToId(false); + m_options.SetUnwindOnError(true); + m_options.SetKeepInMemory(true); + m_options.SetUseDynamic(lldb::eDynamicCanRunTarget); +} + +bool +LibstdcppMapIteratorSyntheticFrontEnd::Update() +{ + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + + TargetSP target_sp(valobj_sp->GetTargetSP()); + + if (!target_sp) + return false; + + bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8); + + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + + ValueObjectSP _M_node_sp(valobj_sp->GetChildMemberWithName(ConstString("_M_node"), true)); + if (!_M_node_sp) + return false; + + m_pair_address = _M_node_sp->GetValueAsUnsigned(0); + if (m_pair_address == 0) + return false; + + m_pair_address += (is_64bit ? 32 : 16); + + CompilerType my_type(valobj_sp->GetCompilerType()); + if (my_type.GetNumTemplateArguments() >= 1) + { + TemplateArgumentKind kind; + CompilerType pair_type = my_type.GetTemplateArgument(0, kind); + if (kind != eTemplateArgumentKindType && kind != eTemplateArgumentKindTemplate && kind != eTemplateArgumentKindTemplateExpansion) + return false; + m_pair_type = pair_type; + } + else + return false; + + return true; +} + +size_t +LibstdcppMapIteratorSyntheticFrontEnd::CalculateNumChildren () +{ + return 2; +} + +lldb::ValueObjectSP +LibstdcppMapIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (m_pair_address != 0 && m_pair_type) + { + if (!m_pair_sp) + m_pair_sp = CreateValueObjectFromAddress("pair", m_pair_address, m_exe_ctx_ref, m_pair_type); + if (m_pair_sp) + return m_pair_sp->GetChildAtIndex(idx, true); + } + return lldb::ValueObjectSP(); +} + +bool +LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (name == ConstString("first")) + return 0; + if (name == ConstString("second")) + return 1; + return UINT32_MAX; +} + +LibstdcppMapIteratorSyntheticFrontEnd::~LibstdcppMapIteratorSyntheticFrontEnd () +{} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return NULL; + return (new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp)); +} + +/* + (lldb) fr var ibeg --ptr-depth 1 + (__gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >) ibeg = { + _M_current = 0x00000001001037a0 { + *_M_current = 1 + } + } + */ + +SyntheticChildrenFrontEnd* +lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + static ConstString g_item_name; + if (!g_item_name) + g_item_name.SetCString("_M_current"); + if (!valobj_sp) + return NULL; + return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name)); +} + +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp, + ConstString item_name) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_exe_ctx_ref(), +m_item_name(item_name), +m_item_sp() +{ + if (valobj_sp) + Update(); +} + +bool +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::Update() +{ + m_item_sp.reset(); + + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + + if (!valobj_sp) + return false; + + ValueObjectSP item_ptr(valobj_sp->GetChildMemberWithName(m_item_name,true)); + if (!item_ptr) + return false; + if (item_ptr->GetValueAsUnsigned(0) == 0) + return false; + Error err; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + m_item_sp = CreateValueObjectFromAddress("item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref, item_ptr->GetCompilerType().GetPointeeType()); + if (err.Fail()) + m_item_sp.reset(); + return false; +} + +size_t +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::CalculateNumChildren () +{ + return 1; +} + +lldb::ValueObjectSP +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (idx == 0) + return m_item_sp; + return lldb::ValueObjectSP(); +} + +bool +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + if (name == ConstString("item")) + return 0; + return UINT32_MAX; +} + +lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSyntheticFrontEnd () +{ +} + +bool +lldb_private::formatters::LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + const bool scalar_is_load_addr = true; + AddressType addr_type; + lldb::addr_t addr_of_string = valobj.GetAddressOf(scalar_is_load_addr, &addr_type); + if (addr_of_string != LLDB_INVALID_ADDRESS) + { + switch (addr_type) + { + case eAddressTypeLoad: + { + ProcessSP process_sp(valobj.GetProcessSP()); + if (!process_sp) + return false; + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + Error error; + lldb::addr_t addr_of_data = process_sp->ReadPointerFromMemory(addr_of_string, error); + if (error.Fail() || addr_of_data == 0 || addr_of_data == LLDB_INVALID_ADDRESS) + return false; + options.SetLocation(addr_of_data); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetNeedsZeroTermination(false); + options.SetBinaryZeroIsTerminator(true); + lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(addr_of_string + process_sp->GetAddressByteSize(), error); + if (error.Fail()) + return false; + options.SetSourceSize(size_of_data); + + if (!StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(options)) + { + stream.Printf("Summary Unavailable"); + return true; + } + else + return true; + } + break; + case eAddressTypeHost: + break; + case eAddressTypeInvalid: + case eAddressTypeFile: + break; + } + } + return false; +} + +bool +lldb_private::formatters::LibStdcppWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + const bool scalar_is_load_addr = true; + AddressType addr_type; + lldb::addr_t addr_of_string = valobj.GetAddressOf(scalar_is_load_addr, &addr_type); + if (addr_of_string != LLDB_INVALID_ADDRESS) + { + switch (addr_type) + { + case eAddressTypeLoad: + { + ProcessSP process_sp(valobj.GetProcessSP()); + if (!process_sp) + return false; + + CompilerType wchar_compiler_type = valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar); + + if (!wchar_compiler_type) + return false; + + const uint32_t wchar_size = wchar_compiler_type.GetBitSize(nullptr); // Safe to pass NULL for exe_scope here + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + Error error; + lldb::addr_t addr_of_data = process_sp->ReadPointerFromMemory(addr_of_string, error); + if (error.Fail() || addr_of_data == 0 || addr_of_data == LLDB_INVALID_ADDRESS) + return false; + options.SetLocation(addr_of_data); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetNeedsZeroTermination(false); + options.SetBinaryZeroIsTerminator(false); + lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(addr_of_string + process_sp->GetAddressByteSize(), error); + if (error.Fail()) + return false; + options.SetSourceSize(size_of_data); + options.SetPrefixToken("L"); + + switch (wchar_size) + { + case 8: + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(options); + case 16: + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); + case 32: + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF32>(options); + default: + stream.Printf("size for wchar_t is not valid"); + return true; + } + return true; + } + break; + case eAddressTypeHost: + break; + case eAddressTypeInvalid: + case eAddressTypeFile: + break; + } + } + return false; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.h b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.h new file mode 100644 index 000000000000..347856a1695c --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.h @@ -0,0 +1,33 @@ +//===-- LibStdCpp.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_LibStdCpp_h_ +#define liblldb_LibStdCpp_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +namespace lldb_private { + namespace formatters + { + bool + LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libcstdc++ c++11 std::string + + bool + LibStdcppWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libcstdc++ c++11 std::wstring + + SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_LibStdCpp_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoFormatterFunctions.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoFormatterFunctions.cpp new file mode 100644 index 000000000000..1d7cd76b9739 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoFormatterFunctions.cpp @@ -0,0 +1,173 @@ +//===-- GoFormatterFunctions.cpp---------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +#include <map> + +// Other libraries and framework includes +// Project includes +#include "GoFormatterFunctions.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/StringPrinter.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace +{ +class GoSliceSyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ + public: + GoSliceSyntheticFrontEnd(ValueObject &valobj) + : SyntheticChildrenFrontEnd(valobj) + { + Update(); + } + + ~GoSliceSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override + { + return m_len; + } + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override + { + if (idx < m_len) + { + ValueObjectSP &cached = m_children[idx]; + if (!cached) + { + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + lldb::addr_t object_at_idx = m_base_data_address; + object_at_idx += idx * m_type.GetByteSize(nullptr); + cached = CreateValueObjectFromAddress(idx_name.GetData(), object_at_idx, + m_backend.GetExecutionContextRef(), m_type); + } + return cached; + } + return ValueObjectSP(); + } + + bool + Update() override + { + size_t old_count = m_len; + + ConstString array_const_str("array"); + ValueObjectSP array_sp = m_backend.GetChildMemberWithName(array_const_str, true); + if (!array_sp) + { + m_children.clear(); + return old_count == 0; + } + m_type = array_sp->GetCompilerType().GetPointeeType(); + m_base_data_address = array_sp->GetPointerValue(); + + ConstString len_const_str("len"); + ValueObjectSP len_sp = m_backend.GetChildMemberWithName(len_const_str, true); + if (len_sp) + { + m_len = len_sp->GetValueAsUnsigned(0); + m_children.clear(); + } + + return old_count == m_len; + } + + bool + MightHaveChildren() override + { + return true; + } + + size_t + GetIndexOfChildWithName(const ConstString &name) override + { + return ExtractIndexFromString(name.AsCString()); + } + + private: + CompilerType m_type; + lldb::addr_t m_base_data_address; + size_t m_len; + std::map<size_t, lldb::ValueObjectSP> m_children; +}; + +} // anonymous namespace + +bool +lldb_private::formatters::GoStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &opts) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + if (valobj.IsPointerType()) + { + Error err; + ValueObjectSP deref = valobj.Dereference(err); + if (!err.Success()) + return false; + return GoStringSummaryProvider(*deref, stream, opts); + } + + ConstString str_name("str"); + ConstString len_name("len"); + + ValueObjectSP data_sp = valobj.GetChildMemberWithName(str_name, true); + ValueObjectSP len_sp = valobj.GetChildMemberWithName(len_name, true); + if (!data_sp || !len_sp) + return false; + bool success; + lldb::addr_t valobj_addr = data_sp->GetValueAsUnsigned(0, &success); + + if (!success) + return false; + + uint64_t length = len_sp->GetValueAsUnsigned(0); + if (length == 0) + { + stream.Printf("\"\""); + return true; + } + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + options.SetLocation(valobj_addr); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetSourceSize(length); + options.SetNeedsZeroTermination(false); + options.SetLanguage(eLanguageTypeGo); + + if (!StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(options)) + { + stream.Printf("Summary Unavailable"); + return true; + } + + return true; +} + +SyntheticChildrenFrontEnd * +lldb_private::formatters::GoSliceSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return nullptr; + + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return nullptr; + return new GoSliceSyntheticFrontEnd(*valobj_sp); +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoFormatterFunctions.h b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoFormatterFunctions.h new file mode 100644 index 000000000000..ae1eda0f0c54 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoFormatterFunctions.h @@ -0,0 +1,43 @@ +//===-- GoFormatterFunctions.h-----------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_GoFormatterFunctions_h_ +#define liblldb_GoFormatterFunctions_h_ + +// C Includes +#include <stdint.h> +#include <time.h> + +// C++ Includes +// Other libraries and framework includes +#include "clang/AST/ASTContext.h" + +// Project includes +#include "lldb/lldb-forward.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/DataFormatters/FormatClasses.h" +#include "lldb/DataFormatters/TypeSynthetic.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Target.h" + +namespace lldb_private +{ +namespace formatters +{ + +bool GoStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options); + +SyntheticChildrenFrontEnd *GoSliceSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP); + +} // namespace formatters +} // namespace lldb_private + +#endif // liblldb_GoFormatterFunctions_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoLanguage.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoLanguage.cpp new file mode 100644 index 000000000000..ed010ffa4b2e --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoLanguage.cpp @@ -0,0 +1,146 @@ +//===-- GoLanguage.cpp ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +#include <string.h> +// C++ Includes +#include <functional> +#include <mutex> + +// Other libraries and framework includes +#include "llvm/ADT/StringRef.h" + +// Project includes +#include "GoLanguage.h" +#include "lldb/Core/ConstString.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Symbol/GoASTContext.h" +#include "Plugins/Language/Go/GoFormatterFunctions.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +void +GoLanguage::Initialize() +{ + PluginManager::RegisterPlugin(GetPluginNameStatic(), "Go Language", CreateInstance); +} + +void +GoLanguage::Terminate() +{ + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString +GoLanguage::GetPluginNameStatic() +{ + static ConstString g_name("Go"); + return g_name; +} + +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +lldb_private::ConstString +GoLanguage::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +GoLanguage::GetPluginVersion() +{ + return 1; +} + +//------------------------------------------------------------------ +// Static Functions +//------------------------------------------------------------------ +Language * +GoLanguage::CreateInstance(lldb::LanguageType language) +{ + if (language == eLanguageTypeGo) + return new GoLanguage(); + return nullptr; +} + +HardcodedFormatters::HardcodedSummaryFinder +GoLanguage::GetHardcodedSummaries() +{ + static std::once_flag g_initialize; + static HardcodedFormatters::HardcodedSummaryFinder g_formatters; + + std::call_once(g_initialize, []() -> void + { + g_formatters.push_back( + [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, + FormatManager &) -> TypeSummaryImpl::SharedPointer + { + static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat( + TypeSummaryImpl::Flags().SetDontShowChildren(true), + lldb_private::formatters::GoStringSummaryProvider, "Go string summary provider")); + if (GoASTContext::IsGoString(valobj.GetCompilerType())) + { + return formatter_sp; + } + if (GoASTContext::IsGoString(valobj.GetCompilerType().GetPointeeType())) + { + return formatter_sp; + } + return nullptr; + }); + g_formatters.push_back( + [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, + FormatManager &) -> TypeSummaryImpl::SharedPointer + { + static lldb::TypeSummaryImplSP formatter_sp( + new StringSummaryFormat(TypeSummaryImpl::Flags().SetHideItemNames(true), + "(len ${var.len}, cap ${var.cap})")); + if (GoASTContext::IsGoSlice(valobj.GetCompilerType())) + { + return formatter_sp; + } + if (GoASTContext::IsGoSlice(valobj.GetCompilerType().GetPointeeType())) + { + return formatter_sp; + } + return nullptr; + }); + }); + return g_formatters; +} + +HardcodedFormatters::HardcodedSyntheticFinder +GoLanguage::GetHardcodedSynthetics() +{ + static std::once_flag g_initialize; + static HardcodedFormatters::HardcodedSyntheticFinder g_formatters; + + std::call_once(g_initialize, []() -> void + { + g_formatters.push_back( + [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, + FormatManager &fmt_mgr) -> SyntheticChildren::SharedPointer + { + static CXXSyntheticChildren::SharedPointer formatter_sp( + new CXXSyntheticChildren(SyntheticChildren::Flags(), "slice synthetic children", + lldb_private::formatters::GoSliceSyntheticFrontEndCreator)); + if (GoASTContext::IsGoSlice(valobj.GetCompilerType())) + { + return formatter_sp; + } + return nullptr; + }); + }); + + return g_formatters; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoLanguage.h b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoLanguage.h new file mode 100644 index 000000000000..67dd04c2a22e --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/Go/GoLanguage.h @@ -0,0 +1,66 @@ +//===-- GoLanguage.h --------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_GoLanguage_h_ +#define liblldb_GoLanguage_h_ + +// C Includes +// C++ Includes +#include <vector> + +// Other libraries and framework includes +#include "llvm/ADT/StringRef.h" + +// Project includes +#include "lldb/lldb-private.h" +#include "lldb/Core/ConstString.h" +#include "lldb/Target/Language.h" + +namespace lldb_private +{ + +class GoLanguage : public Language +{ + public: + GoLanguage() = default; + + ~GoLanguage() override = default; + + lldb::LanguageType + GetLanguageType() const override + { + return lldb::eLanguageTypeGo; + } + + HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries() override; + + HardcodedFormatters::HardcodedSyntheticFinder GetHardcodedSynthetics() override; + + //------------------------------------------------------------------ + // Static Functions + //------------------------------------------------------------------ + static void Initialize(); + + static void Terminate(); + + static lldb_private::Language *CreateInstance(lldb::LanguageType language); + + static lldb_private::ConstString GetPluginNameStatic(); + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; +}; + +} // namespace lldb_private + +#endif // liblldb_GoLanguage_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CF.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CF.cpp new file mode 100644 index 000000000000..614eb29a0f7a --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CF.cpp @@ -0,0 +1,334 @@ +//===-- CF.cpp ----------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "CF.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::CFAbsoluteTimeSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + time_t epoch = GetOSXEpoch(); + epoch = epoch + (time_t)valobj.GetValueAsUnsigned(0); + tm *tm_date = localtime(&epoch); + if (!tm_date) + return false; + std::string buffer(1024,0); + if (strftime (&buffer[0], 1023, "%Z", tm_date) == 0) + return false; + stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year+1900, tm_date->tm_mon+1, tm_date->tm_mday, tm_date->tm_hour, tm_date->tm_min, tm_date->tm_sec, buffer.c_str()); + return true; +} + +bool +lldb_private::formatters::CFBagSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + static ConstString g_TypeHint("CFBag"); + + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint32_t count = 0; + + bool is_type_ok = false; // check to see if this is a CFBag we know about + if (descriptor->IsCFType()) + { + ConstString type_name(valobj.GetTypeName()); + if (type_name == ConstString("__CFBag") || type_name == ConstString("const struct __CFBag")) + { + if (valobj.IsPointerType()) + is_type_ok = true; + } + } + + if (is_type_ok == false) + { + StackFrameSP frame_sp(valobj.GetFrameSP()); + if (!frame_sp) + return false; + ValueObjectSP count_sp; + StreamString expr; + expr.Printf("(int)CFBagGetCount((void*)0x%" PRIx64 ")",valobj.GetPointerValue()); + EvaluateExpressionOptions options; + options.SetResultIsInternal(true); + if (process_sp->GetTarget().EvaluateExpression(expr.GetData(), frame_sp.get(), count_sp, options) != eExpressionCompleted) + return false; + if (!count_sp) + return false; + count = count_sp->GetValueAsUnsigned(0); + } + else + { + uint32_t offset = 2*ptr_size+4 + valobj_addr; + Error error; + count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error); + if (error.Fail()) + return false; + } + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s\"%u value%s\"%s", + prefix.c_str(), + count,(count == 1 ? "" : "s"), + suffix.c_str()); + return true; +} + +bool +lldb_private::formatters::CFBitVectorSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint32_t count = 0; + + bool is_type_ok = false; // check to see if this is a CFBag we know about + if (descriptor->IsCFType()) + { + ConstString type_name(valobj.GetTypeName()); + if (type_name == ConstString("__CFMutableBitVector") || type_name == ConstString("__CFBitVector") || type_name == ConstString("CFMutableBitVectorRef") || type_name == ConstString("CFBitVectorRef")) + { + if (valobj.IsPointerType()) + is_type_ok = true; + } + } + + if (is_type_ok == false) + return false; + + Error error; + count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + uint64_t num_bytes = count / 8 + ((count & 7) ? 1 : 0); + addr_t data_ptr = process_sp->ReadPointerFromMemory(valobj_addr+2*ptr_size+2*ptr_size, error); + if (error.Fail()) + return false; + // make sure we do not try to read huge amounts of data + if (num_bytes > 1024) + num_bytes = 1024; + DataBufferSP buffer_sp(new DataBufferHeap(num_bytes,0)); + num_bytes = process_sp->ReadMemory(data_ptr, buffer_sp->GetBytes(), num_bytes, error); + if (error.Fail() || num_bytes == 0) + return false; + uint8_t *bytes = buffer_sp->GetBytes(); + for (uint64_t byte_idx = 0; byte_idx < num_bytes-1; byte_idx++) + { + uint8_t byte = bytes[byte_idx]; + bool bit0 = (byte & 1) == 1; + bool bit1 = (byte & 2) == 2; + bool bit2 = (byte & 4) == 4; + bool bit3 = (byte & 8) == 8; + bool bit4 = (byte & 16) == 16; + bool bit5 = (byte & 32) == 32; + bool bit6 = (byte & 64) == 64; + bool bit7 = (byte & 128) == 128; + stream.Printf("%c%c%c%c %c%c%c%c ", + (bit7 ? '1' : '0'), + (bit6 ? '1' : '0'), + (bit5 ? '1' : '0'), + (bit4 ? '1' : '0'), + (bit3 ? '1' : '0'), + (bit2 ? '1' : '0'), + (bit1 ? '1' : '0'), + (bit0 ? '1' : '0')); + count -= 8; + } + { + // print the last byte ensuring we do not print spurious bits + uint8_t byte = bytes[num_bytes-1]; + bool bit0 = (byte & 1) == 1; + bool bit1 = (byte & 2) == 2; + bool bit2 = (byte & 4) == 4; + bool bit3 = (byte & 8) == 8; + bool bit4 = (byte & 16) == 16; + bool bit5 = (byte & 32) == 32; + bool bit6 = (byte & 64) == 64; + bool bit7 = (byte & 128) == 128; + if (count) + { + stream.Printf("%c",bit7 ? '1' : '0'); + count -= 1; + } + if (count) + { + stream.Printf("%c",bit6 ? '1' : '0'); + count -= 1; + } + if (count) + { + stream.Printf("%c",bit5 ? '1' : '0'); + count -= 1; + } + if (count) + { + stream.Printf("%c",bit4 ? '1' : '0'); + count -= 1; + } + if (count) + { + stream.Printf("%c",bit3 ? '1' : '0'); + count -= 1; + } + if (count) + { + stream.Printf("%c",bit2 ? '1' : '0'); + count -= 1; + } + if (count) + { + stream.Printf("%c",bit1 ? '1' : '0'); + count -= 1; + } + if (count) + stream.Printf("%c",bit0 ? '1' : '0'); + } + return true; +} + +bool +lldb_private::formatters::CFBinaryHeapSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + static ConstString g_TypeHint("CFBinaryHeap"); + + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint32_t count = 0; + + bool is_type_ok = false; // check to see if this is a CFBinaryHeap we know about + if (descriptor->IsCFType()) + { + ConstString type_name(valobj.GetTypeName()); + if (type_name == ConstString("__CFBinaryHeap") || type_name == ConstString("const struct __CFBinaryHeap")) + { + if (valobj.IsPointerType()) + is_type_ok = true; + } + } + + if (is_type_ok == false) + { + StackFrameSP frame_sp(valobj.GetFrameSP()); + if (!frame_sp) + return false; + ValueObjectSP count_sp; + StreamString expr; + expr.Printf("(int)CFBinaryHeapGetCount((void*)0x%" PRIx64 ")",valobj.GetPointerValue()); + EvaluateExpressionOptions options; + options.SetResultIsInternal(true); + if (process_sp->GetTarget().EvaluateExpression(expr.GetData(), frame_sp.get(), count_sp, options) != eExpressionCompleted) + return false; + if (!count_sp) + return false; + count = count_sp->GetValueAsUnsigned(0); + } + else + { + uint32_t offset = 2*ptr_size; + Error error; + count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error); + if (error.Fail()) + return false; + } + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s\"%u item%s\"%s", + prefix.c_str(), + count,(count == 1 ? "" : "s"), + suffix.c_str()); + return true; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CF.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CF.h new file mode 100644 index 000000000000..4044f09f585e --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CF.h @@ -0,0 +1,34 @@ +//===-- CF.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_CF_h_ +#define liblldb_CF_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" + +namespace lldb_private { + namespace formatters + { + bool + CFBagSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + CFBinaryHeapSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + CFBitVectorSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + CFAbsoluteTimeSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_CF_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/Cocoa.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/Cocoa.cpp new file mode 100644 index 000000000000..aa6e476b6131 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/Cocoa.cpp @@ -0,0 +1,967 @@ +//===-- Cocoa.cpp -----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "Cocoa.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Mangled.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/StringPrinter.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Process.h" +#include "lldb/Utility/ProcessStructReader.h" + +#include "NSString.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::NSBundleSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"NSBundle")) + { + uint64_t offset = 5 * ptr_size; + ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID), true)); + + StreamString summary_stream; + bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options); + if (was_nsstring_ok && summary_stream.GetSize() > 0) + { + stream.Printf("%s",summary_stream.GetData()); + return true; + } + } + // this is either an unknown subclass or an NSBundle that comes from [NSBundle mainBundle] + // which is encoded differently and needs to be handled by running code + return ExtractSummaryFromObjCExpression(valobj, "NSString*", "bundlePath", stream, options.GetLanguage()); +} + +bool +lldb_private::formatters::NSTimeZoneSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"__NSTimeZone")) + { + uint64_t offset = ptr_size; + ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType(), true)); + StreamString summary_stream; + bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options); + if (was_nsstring_ok && summary_stream.GetSize() > 0) + { + stream.Printf("%s",summary_stream.GetData()); + return true; + } + } + return ExtractSummaryFromObjCExpression(valobj, "NSString*", "name", stream, options.GetLanguage()); +} + +bool +lldb_private::formatters::NSNotificationSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"NSConcreteNotification")) + { + uint64_t offset = ptr_size; + ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType(), true)); + StreamString summary_stream; + bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options); + if (was_nsstring_ok && summary_stream.GetSize() > 0) + { + stream.Printf("%s",summary_stream.GetData()); + return true; + } + } + // this is either an unknown subclass or an NSBundle that comes from [NSBundle mainBundle] + // which is encoded differently and needs to be handled by running code + return ExtractSummaryFromObjCExpression(valobj, "NSString*", "name", stream, options.GetLanguage()); +} + +bool +lldb_private::formatters::NSMachPortSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + uint64_t port_number = 0; + + do + { + if (!strcmp(class_name,"NSMachPort")) + { + uint64_t offset = (ptr_size == 4 ? 12 : 20); + Error error; + port_number = process_sp->ReadUnsignedIntegerFromMemory(offset+valobj_addr, 4, 0, error); + if (error.Success()) + break; + } + if (!ExtractValueFromObjCExpression(valobj, "int", "machPort", port_number)) + return false; + } while (false); + + stream.Printf("mach port: %u",(uint32_t)(port_number & 0x00000000FFFFFFFF)); + return true; +} + +bool +lldb_private::formatters::NSIndexSetSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + uint64_t count = 0; + + do { + if (!strcmp(class_name,"NSIndexSet") || !strcmp(class_name,"NSMutableIndexSet")) + { + Error error; + uint32_t mode = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+ptr_size, 4, 0, error); + if (error.Fail()) + return false; + // this means the set is empty - count = 0 + if ((mode & 1) == 1) + { + count = 0; + break; + } + if ((mode & 2) == 2) + mode = 1; // this means the set only has one range + else + mode = 2; // this means the set has multiple ranges + if (mode == 1) + { + count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+3*ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + } + else + { + // read a pointer to the data at 2*ptr_size + count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + // read the data at 2*ptr_size from the first location + count = process_sp->ReadUnsignedIntegerFromMemory(count+2*ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + } + } + else + { + if (!ExtractValueFromObjCExpression(valobj, "unsigned long long int", "count", count)) + return false; + } + } while (false); + stream.Printf("%" PRIu64 " index%s", + count, + (count == 1 ? "" : "es")); + return true; +} + +static void +NSNumber_FormatChar (ValueObject& valobj, + Stream& stream, + char value, + lldb::LanguageType lang) +{ + static ConstString g_TypeHint("NSNumber:char"); + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(lang)) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%hhd%s", + prefix.c_str(), + value, + suffix.c_str()); +} + +static void +NSNumber_FormatShort (ValueObject& valobj, + Stream& stream, + short value, + lldb::LanguageType lang) +{ + static ConstString g_TypeHint("NSNumber:short"); + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(lang)) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%hd%s", + prefix.c_str(), + value, + suffix.c_str()); +} + +static void +NSNumber_FormatInt (ValueObject& valobj, + Stream& stream, + int value, + lldb::LanguageType lang) +{ + static ConstString g_TypeHint("NSNumber:int"); + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(lang)) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%d%s", + prefix.c_str(), + value, + suffix.c_str()); +} + +static void +NSNumber_FormatLong (ValueObject& valobj, + Stream& stream, + uint64_t value, + lldb::LanguageType lang) +{ + static ConstString g_TypeHint("NSNumber:long"); + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(lang)) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%" PRId64 "%s", + prefix.c_str(), + value, + suffix.c_str()); +} + +static void +NSNumber_FormatFloat (ValueObject& valobj, + Stream& stream, + float value, + lldb::LanguageType lang) +{ + static ConstString g_TypeHint("NSNumber:float"); + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(lang)) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%f%s", + prefix.c_str(), + value, + suffix.c_str()); +} + +static void +NSNumber_FormatDouble (ValueObject& valobj, + Stream& stream, + double value, + lldb::LanguageType lang) +{ + static ConstString g_TypeHint("NSNumber:double"); + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(lang)) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%g%s", + prefix.c_str(), + value, + suffix.c_str()); +} + +bool +lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"NSNumber") || !strcmp(class_name,"__NSCFNumber")) + { + uint64_t value = 0; + uint64_t i_bits = 0; + if (descriptor->GetTaggedPointerInfo(&i_bits,&value)) + { + switch (i_bits) + { + case 0: + NSNumber_FormatChar(valobj, stream, (char)value, options.GetLanguage()); + break; + case 1: + case 4: + NSNumber_FormatShort(valobj, stream, (short)value, options.GetLanguage()); + break; + case 2: + case 8: + NSNumber_FormatInt(valobj, stream, (int)value, options.GetLanguage()); + break; + case 3: + case 12: + NSNumber_FormatLong(valobj, stream, value, options.GetLanguage()); + break; + default: + return false; + } + return true; + } + else + { + Error error; + uint8_t data_type = (process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, 1, 0, error) & 0x1F); + uint64_t data_location = valobj_addr + 2*ptr_size; + uint64_t value = 0; + if (error.Fail()) + return false; + switch (data_type) + { + case 1: // 0B00001 + value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 1, 0, error); + if (error.Fail()) + return false; + NSNumber_FormatChar(valobj, stream, (char)value, options.GetLanguage()); + break; + case 2: // 0B0010 + value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 2, 0, error); + if (error.Fail()) + return false; + NSNumber_FormatShort(valobj, stream, (short)value, options.GetLanguage()); + break; + case 3: // 0B0011 + value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0, error); + if (error.Fail()) + return false; + NSNumber_FormatInt(valobj, stream, (int)value, options.GetLanguage()); + break; + case 17: // 0B10001 + data_location += 8; + case 4: // 0B0100 + value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, error); + if (error.Fail()) + return false; + NSNumber_FormatLong(valobj, stream, value, options.GetLanguage()); + break; + case 5: // 0B0101 + { + uint32_t flt_as_int = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0, error); + if (error.Fail()) + return false; + float flt_value = *((float*)&flt_as_int); + NSNumber_FormatFloat(valobj, stream, flt_value, options.GetLanguage()); + break; + } + case 6: // 0B0110 + { + uint64_t dbl_as_lng = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, error); + if (error.Fail()) + return false; + double dbl_value = *((double*)&dbl_as_lng); + NSNumber_FormatDouble(valobj, stream, dbl_value, options.GetLanguage()); + break; + } + default: + return false; + } + return true; + } + } + else + { + return ExtractSummaryFromObjCExpression(valobj, "NSString*", "stringValue", stream, options.GetLanguage()); + } +} + +bool +lldb_private::formatters::NSURLSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (strcmp(class_name, "NSURL") == 0) + { + uint64_t offset_text = ptr_size + ptr_size + 8; // ISA + pointer + 8 bytes of data (even on 32bit) + uint64_t offset_base = offset_text + ptr_size; + CompilerType type(valobj.GetCompilerType()); + ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset_text, type, true)); + ValueObjectSP base(valobj.GetSyntheticChildAtOffset(offset_base, type, true)); + if (!text) + return false; + if (text->GetValueAsUnsigned(0) == 0) + return false; + StreamString summary; + if (!NSStringSummaryProvider(*text, summary, options)) + return false; + if (base && base->GetValueAsUnsigned(0)) + { + if (summary.GetSize() > 0) + summary.GetString().resize(summary.GetSize()-1); + summary.Printf(" -- "); + StreamString base_summary; + if (NSURLSummaryProvider(*base, base_summary, options) && base_summary.GetSize() > 0) + summary.Printf("%s",base_summary.GetSize() > 2 ? base_summary.GetData() + 2 : base_summary.GetData()); + } + if (summary.GetSize()) + { + stream.Printf("%s",summary.GetData()); + return true; + } + } + else + { + return ExtractSummaryFromObjCExpression(valobj, "NSString*", "description", stream, options.GetLanguage()); + } + return false; +} + +bool +lldb_private::formatters::NSDateSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint64_t date_value_bits = 0; + double date_value = 0.0; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (strcmp(class_name,"NSDate") == 0 || + strcmp(class_name,"__NSDate") == 0 || + strcmp(class_name,"__NSTaggedDate") == 0) + { + uint64_t info_bits=0,value_bits = 0; + if (descriptor->GetTaggedPointerInfo(&info_bits,&value_bits)) + { + date_value_bits = ((value_bits << 8) | (info_bits << 4)); + date_value = *((double*)&date_value_bits); + } + else + { + Error error; + date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+ptr_size, 8, 0, error); + date_value = *((double*)&date_value_bits); + if (error.Fail()) + return false; + } + } + else if (!strcmp(class_name,"NSCalendarDate")) + { + Error error; + date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, 8, 0, error); + date_value = *((double*)&date_value_bits); + if (error.Fail()) + return false; + } + else + { + if (ExtractValueFromObjCExpression(valobj, "NSTimeInterval", "ExtractValueFromObjCExpression", date_value_bits) == false) + return false; + date_value = *((double*)&date_value_bits); + } + if (date_value == -63114076800) + { + stream.Printf("0001-12-30 00:00:00 +0000"); + return true; + } + // this snippet of code assumes that time_t == seconds since Jan-1-1970 + // this is generally true and POSIXly happy, but might break if a library + // vendor decides to get creative + time_t epoch = GetOSXEpoch(); + epoch = epoch + (time_t)date_value; + tm *tm_date = gmtime(&epoch); + if (!tm_date) + return false; + std::string buffer(1024,0); + if (strftime (&buffer[0], 1023, "%Z", tm_date) == 0) + return false; + stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year+1900, tm_date->tm_mon+1, tm_date->tm_mday, tm_date->tm_hour, tm_date->tm_min, tm_date->tm_sec, buffer.c_str()); + return true; +} + +bool +lldb_private::formatters::ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0))); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + ConstString class_name = descriptor->GetClassName(); + + if (class_name.IsEmpty()) + return false; + + if (ConstString cs = Mangled(class_name).GetDemangledName(lldb::eLanguageTypeUnknown)) + class_name = cs; + + stream.Printf("%s",class_name.AsCString("<unknown class>")); + return true; +} + +class ObjCClassSyntheticChildrenFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + ObjCClassSyntheticChildrenFrontEnd (lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd(*valobj_sp.get()) + { + } + + ~ObjCClassSyntheticChildrenFrontEnd() override = default; + + size_t + CalculateNumChildren() override + { + return 0; + } + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override + { + return lldb::ValueObjectSP(); + } + + bool + Update() override + { + return false; + } + + bool + MightHaveChildren() override + { + return false; + } + + size_t + GetIndexOfChildWithName(const ConstString &name) override + { + return UINT32_MAX; + } +}; + +SyntheticChildrenFrontEnd* +lldb_private::formatters::ObjCClassSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp); +} + +template<bool needs_at> +bool +lldb_private::formatters::NSDataSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + bool is_64bit = (process_sp->GetAddressByteSize() == 8); + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint64_t value = 0; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"NSConcreteData") || + !strcmp(class_name,"NSConcreteMutableData") || + !strcmp(class_name,"__NSCFData")) + { + uint32_t offset = (is_64bit ? 16 : 8); + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + offset, is_64bit ? 8 : 4, 0, error); + if (error.Fail()) + return false; + } + else + { + if (!ExtractValueFromObjCExpression(valobj, "int", "length", value)) + return false; + } + + stream.Printf("%s%" PRIu64 " byte%s%s", + (needs_at ? "@\"" : ""), + value, + (value != 1 ? "s" : ""), + (needs_at ? "\"" : "")); + + return true; +} + +bool +lldb_private::formatters::ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo(); + + ValueObjectSP real_guy_sp = valobj.GetSP(); + + if (type_info & eTypeIsPointer) + { + Error err; + real_guy_sp = valobj.Dereference(err); + if (err.Fail() || !real_guy_sp) + return false; + } + else if (type_info & eTypeIsReference) + { + real_guy_sp = valobj.GetChildAtIndex(0, true); + if (!real_guy_sp) + return false; + } + uint64_t value = real_guy_sp->GetValueAsUnsigned(0); + if (value == 0) + { + stream.Printf("NO"); + return true; + } + stream.Printf("YES"); + return true; +} + +template <bool is_sel_ptr> +bool +lldb_private::formatters::ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + lldb::ValueObjectSP valobj_sp; + + CompilerType charstar (valobj.GetCompilerType().GetBasicTypeFromAST(eBasicTypeChar).GetPointerType()); + + if (!charstar) + return false; + + ExecutionContext exe_ctx(valobj.GetExecutionContextRef()); + + if (is_sel_ptr) + { + lldb::addr_t data_address = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + if (data_address == LLDB_INVALID_ADDRESS) + return false; + valobj_sp = ValueObject::CreateValueObjectFromAddress("text", data_address, exe_ctx, charstar); + } + else + { + DataExtractor data; + Error error; + valobj.GetData(data, error); + if (error.Fail()) + return false; + valobj_sp = ValueObject::CreateValueObjectFromData("text", data, exe_ctx, charstar); + } + + if (!valobj_sp) + return false; + + stream.Printf("%s",valobj_sp->GetSummaryAsCString()); + return true; +} + +// POSIX has an epoch on Jan-1-1970, but Cocoa prefers Jan-1-2001 +// this call gives the POSIX equivalent of the Cocoa epoch +time_t +lldb_private::formatters::GetOSXEpoch () +{ + static time_t epoch = 0; + if (!epoch) + { +#ifndef _WIN32 + tzset(); + tm tm_epoch; + tm_epoch.tm_sec = 0; + tm_epoch.tm_hour = 0; + tm_epoch.tm_min = 0; + tm_epoch.tm_mon = 0; + tm_epoch.tm_mday = 1; + tm_epoch.tm_year = 2001-1900; // for some reason, we need to subtract 1900 from this field. not sure why. + tm_epoch.tm_isdst = -1; + tm_epoch.tm_gmtoff = 0; + tm_epoch.tm_zone = NULL; + epoch = timegm(&tm_epoch); +#endif + } + return epoch; +} + +bool +lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + if (const char* description = valobj.GetObjectDescription()) + { + stream.Printf("%s", description); + return true; + } + else + return false; +} + +template bool +lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&); + +template bool +lldb_private::formatters::NSDataSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&); + +template bool +lldb_private::formatters::ObjCSELSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&); + +template bool +lldb_private::formatters::ObjCSELSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&); diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/Cocoa.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/Cocoa.h new file mode 100644 index 000000000000..0caacf3453d4 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/Cocoa.h @@ -0,0 +1,97 @@ +//===-- Cocoa.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_Cocoa_h_ +#define liblldb_Cocoa_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/Target/ObjCLanguageRuntime.h" + +namespace lldb_private { + namespace formatters + { + bool + NSIndexSetSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSArraySummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + template<bool needs_at> + bool + NSDataSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSNumberSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSNotificationSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSTimeZoneSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSMachPortSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSDateSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSBundleSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSURLSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + extern template bool + NSDataSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ; + + extern template bool + NSDataSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ; + + SyntheticChildrenFrontEnd* NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* NSIndexPathSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + bool + ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + SyntheticChildrenFrontEnd* ObjCClassSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + bool + ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + template <bool is_sel_ptr> + bool + ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + extern template bool + ObjCSELSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&); + + extern template bool + ObjCSELSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&); + + bool + RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSError_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSException_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + SyntheticChildrenFrontEnd* + NSErrorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp); + + SyntheticChildrenFrontEnd* + NSExceptionSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp); + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_Cocoa_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CoreMedia.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CoreMedia.cpp new file mode 100644 index 000000000000..4103067b8d58 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CoreMedia.cpp @@ -0,0 +1,89 @@ +//===-- CoreMedia.cpp --------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "CoreMedia.h" + +#include "lldb/Core/Flags.h" +#include "lldb/Symbol/TypeSystem.h" +#include "lldb/Target/Target.h" +#include <inttypes.h> + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::CMTimeSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + CompilerType type = valobj.GetCompilerType(); + if (!type.IsValid()) + return false; + + TypeSystem *type_system = valobj.GetExecutionContextRef().GetTargetSP()->GetScratchTypeSystemForLanguage(nullptr, lldb::eLanguageTypeC); + if (!type_system) + return false; + + // fetch children by offset to compensate for potential lack of debug info + auto int64_ty = type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64); + auto int32_ty = type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32); + + auto value_sp(valobj.GetSyntheticChildAtOffset(0, int64_ty, true)); + auto timescale_sp(valobj.GetSyntheticChildAtOffset(8, int32_ty, true)); + auto flags_sp(valobj.GetSyntheticChildAtOffset(12, int32_ty, true)); + + if (!value_sp || !timescale_sp || !flags_sp) + return false; + + auto value = value_sp->GetValueAsUnsigned(0); + auto timescale = (int32_t)timescale_sp->GetValueAsUnsigned(0); // the timescale specifies the fraction of a second each unit in the numerator occupies + auto flags = Flags(flags_sp->GetValueAsUnsigned(0) & 0x00000000000000FF); // the flags I need sit in the LSB + + const unsigned int FlagPositiveInf = 4; + const unsigned int FlagNegativeInf = 8; + const unsigned int FlagIndefinite = 16; + + if (flags.AnySet(FlagIndefinite)) + { + stream.Printf("indefinite"); + return true; + } + + if (flags.AnySet(FlagPositiveInf)) + { + stream.Printf("+oo"); + return true; + } + + if (flags.AnySet(FlagNegativeInf)) + { + stream.Printf("-oo"); + return true; + } + + if (timescale == 0) + return false; + + switch (timescale) + { + case 0: + return false; + case 1: + stream.Printf("%" PRId64 " seconds", value); + return true; + case 2: + stream.Printf("%" PRId64 " half seconds", value); + return true; + case 3: + stream.Printf("%" PRId64 " third%sof a second", value, value == 1 ? " " : "s "); + return true; + default: + stream.Printf("%" PRId64 " %" PRId32 "th%sof a second", value, timescale, value == 1 ? " " : "s "); + return true; + } +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CoreMedia.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CoreMedia.h new file mode 100644 index 000000000000..2ffabaadccf5 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/CoreMedia.h @@ -0,0 +1,26 @@ +//===-- CoreMedia.h -----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_CoreMedia_h_ +#define liblldb_CoreMedia_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" + +namespace lldb_private { + namespace formatters + { + + bool + CMTimeSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_CF_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSArray.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSArray.cpp new file mode 100644 index 000000000000..ccc82ab95ecc --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSArray.cpp @@ -0,0 +1,792 @@ +//===-- NSArray.cpp ---------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +#include "clang/AST/ASTContext.h" + +// Project includes +#include "Cocoa.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Expression/FunctionCaller.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace lldb_private { + namespace formatters { + class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSArrayMSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override = 0; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + protected: + virtual lldb::addr_t + GetDataAddress () = 0; + + virtual uint64_t + GetUsedCount () = 0; + + virtual uint64_t + GetOffset () = 0; + + virtual uint64_t + GetSize () = 0; + + ExecutionContextRef m_exe_ctx_ref; + uint8_t m_ptr_size; + CompilerType m_id_type; + std::vector<lldb::ValueObjectSP> m_children; + }; + + class NSArrayMSyntheticFrontEnd_109 : public NSArrayMSyntheticFrontEnd + { + public: + NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp); + + ~NSArrayMSyntheticFrontEnd_109() override; + + bool + Update() override; + + protected: + lldb::addr_t + GetDataAddress() override; + + uint64_t + GetUsedCount() override; + + uint64_t + GetOffset() override; + + uint64_t + GetSize() override; + + private: + struct DataDescriptor_32 + { + uint32_t _used; + uint32_t _priv1 : 2 ; + uint32_t _size : 30; + uint32_t _priv2 : 2; + uint32_t _offset : 30; + uint32_t _priv3; + uint32_t _data; + }; + + struct DataDescriptor_64 + { + uint64_t _used; + uint64_t _priv1 : 2 ; + uint64_t _size : 62; + uint64_t _priv2 : 2; + uint64_t _offset : 62; + uint32_t _priv3; + uint64_t _data; + }; + + DataDescriptor_32 *m_data_32; + DataDescriptor_64 *m_data_64; + }; + + class NSArrayMSyntheticFrontEnd_1010 : public NSArrayMSyntheticFrontEnd + { + public: + NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp); + + ~NSArrayMSyntheticFrontEnd_1010() override; + + bool + Update() override; + + protected: + lldb::addr_t + GetDataAddress() override; + + uint64_t + GetUsedCount() override; + + uint64_t + GetOffset() override; + + uint64_t + GetSize() override; + + private: + struct DataDescriptor_32 + { + uint32_t _used; + uint32_t _offset; + uint32_t _size : 28; + uint64_t _priv1 : 4; + uint32_t _priv2; + uint32_t _data; + }; + + struct DataDescriptor_64 + { + uint64_t _used; + uint64_t _offset; + uint64_t _size : 60; + uint64_t _priv1 : 4; + uint32_t _priv2; + uint64_t _data; + }; + + DataDescriptor_32 *m_data_32; + DataDescriptor_64 *m_data_64; + }; + + class NSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSArrayISyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + ExecutionContextRef m_exe_ctx_ref; + uint8_t m_ptr_size; + uint64_t m_items; + lldb::addr_t m_data_ptr; + CompilerType m_id_type; + std::vector<lldb::ValueObjectSP> m_children; + }; + + class NSArray0SyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSArray0SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSArray0SyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + }; + + class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSArrayCodeRunningSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + }; + } // namespace formatters +} // namespace lldb_private + +bool +lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + static ConstString g_TypeHint("NSArray"); + + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint64_t value = 0; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"__NSArrayI")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + } + else if (!strcmp(class_name,"__NSArrayM")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + } + else if (!strcmp(class_name,"__NSArray0")) + { + value = 0; + } + else if (!strcmp(class_name,"__NSCFArray")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + 2 * ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + } + else + { + if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) + return false; + } + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%" PRIu64 " %s%s%s", + prefix.c_str(), + value, + "element", + value == 1 ? "" : "s", + suffix.c_str()); + return true; +} + +lldb_private::formatters::NSArrayMSyntheticFrontEnd::NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp), +m_exe_ctx_ref(), +m_ptr_size(8), +m_id_type(), +m_children() +{ + if (valobj_sp) + { + clang::ASTContext *ast = valobj_sp->GetExecutionContextRef().GetTargetSP()->GetScratchClangASTContext()->getASTContext(); + if (ast) + m_id_type = CompilerType(ast, ast->ObjCBuiltinIdTy); + if (valobj_sp->GetProcessSP()) + m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize(); + } +} + +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp) : +NSArrayMSyntheticFrontEnd(valobj_sp), +m_data_32(NULL), +m_data_64(NULL) +{ +} + +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp) : +NSArrayMSyntheticFrontEnd(valobj_sp), +m_data_32(NULL), +m_data_64(NULL) +{ +} + +size_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd::CalculateNumChildren () +{ + return GetUsedCount(); +} + +lldb::ValueObjectSP +lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + lldb::addr_t object_at_idx = GetDataAddress(); + size_t pyhs_idx = idx; + pyhs_idx += GetOffset(); + if (GetSize() <= pyhs_idx) + pyhs_idx -= GetSize(); + object_at_idx += (pyhs_idx * m_ptr_size); + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + lldb::ValueObjectSP retval_sp = CreateValueObjectFromAddress(idx_name.GetData(), + object_at_idx, + m_exe_ctx_ref, + m_id_type); + m_children.push_back(retval_sp); + return retval_sp; +} + +bool +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::Update() +{ + m_children.clear(); + ValueObjectSP valobj_sp = m_backend.GetSP(); + m_ptr_size = 0; + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; + if (m_ptr_size == 4) + { + m_data_32 = new DataDescriptor_32(); + process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); + } + else + { + m_data_64 = new DataDescriptor_64(); + process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); + } + if (error.Fail()) + return false; + return false; +} + +bool +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::Update() +{ + m_children.clear(); + ValueObjectSP valobj_sp = m_backend.GetSP(); + m_ptr_size = 0; + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; + if (m_ptr_size == 4) + { + m_data_32 = new DataDescriptor_32(); + process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); + } + else + { + m_data_64 = new DataDescriptor_64(); + process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); + } + if (error.Fail()) + return false; + return false; +} + +bool +lldb_private::formatters::NSArrayMSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::~NSArrayMSyntheticFrontEnd_109() +{ + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; +} + +lldb::addr_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetDataAddress () +{ + if (!m_data_32 && !m_data_64) + return LLDB_INVALID_ADDRESS; + return m_data_32 ? m_data_32->_data : + m_data_64->_data; +} + +uint64_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetUsedCount () +{ + if (!m_data_32 && !m_data_64) + return 0; + return m_data_32 ? m_data_32->_used : + m_data_64->_used; +} + +uint64_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetOffset () +{ + if (!m_data_32 && !m_data_64) + return 0; + return m_data_32 ? m_data_32->_offset : + m_data_64->_offset; +} + +uint64_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetSize () +{ + if (!m_data_32 && !m_data_64) + return 0; + return m_data_32 ? m_data_32->_size : + m_data_64->_size; +} + +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::~NSArrayMSyntheticFrontEnd_1010() +{ + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; +} + +lldb::addr_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetDataAddress () +{ + if (!m_data_32 && !m_data_64) + return LLDB_INVALID_ADDRESS; + return m_data_32 ? m_data_32->_data : + m_data_64->_data; +} + +uint64_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetUsedCount () +{ + if (!m_data_32 && !m_data_64) + return 0; + return m_data_32 ? m_data_32->_used : + m_data_64->_used; +} + +uint64_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetOffset () +{ + if (!m_data_32 && !m_data_64) + return 0; + return m_data_32 ? m_data_32->_offset : + m_data_64->_offset; +} + +uint64_t +lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetSize () +{ + if (!m_data_32 && !m_data_64) + return 0; + return m_data_32 ? m_data_32->_size : + m_data_64->_size; +} + +lldb_private::formatters::NSArrayISyntheticFrontEnd::NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd (*valobj_sp.get()), +m_exe_ctx_ref (), +m_ptr_size (8), +m_items (0), +m_data_ptr (0) +{ + if (valobj_sp) + { + CompilerType type = valobj_sp->GetCompilerType(); + if (type) + { + ClangASTContext *ast = valobj_sp->GetExecutionContextRef().GetTargetSP()->GetScratchClangASTContext(); + if (ast) + m_id_type = CompilerType(ast->getASTContext(), ast->getASTContext()->ObjCBuiltinIdTy); + } + } +} + +size_t +lldb_private::formatters::NSArrayISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +size_t +lldb_private::formatters::NSArrayISyntheticFrontEnd::CalculateNumChildren () +{ + return m_items; +} + +bool +lldb_private::formatters::NSArrayISyntheticFrontEnd::Update() +{ + m_ptr_size = 0; + m_items = 0; + m_data_ptr = 0; + m_children.clear(); + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; + m_items = process_sp->ReadPointerFromMemory(data_location, error); + if (error.Fail()) + return false; + m_data_ptr = data_location+m_ptr_size; + return false; +} + +bool +lldb_private::formatters::NSArrayISyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSArrayISyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + lldb::addr_t object_at_idx = m_data_ptr; + object_at_idx += (idx * m_ptr_size); + ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); + if (!process_sp) + return lldb::ValueObjectSP(); + Error error; + if (error.Fail()) + return lldb::ValueObjectSP(); + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + lldb::ValueObjectSP retval_sp = CreateValueObjectFromAddress(idx_name.GetData(), + object_at_idx, + m_exe_ctx_ref, + m_id_type); + m_children.push_back(retval_sp); + return retval_sp; +} + +lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd (*valobj_sp.get()) +{ +} + +size_t +lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + return UINT32_MAX; +} + +size_t +lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren () +{ + return 0; +} + +bool +lldb_private::formatters::NSArray0SyntheticFrontEnd::Update() +{ + return false; +} + +bool +lldb_private::formatters::NSArray0SyntheticFrontEnd::MightHaveChildren () +{ + return false; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSArray0SyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + return lldb::ValueObjectSP(); +} + +SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + if (!valobj_sp) + return nullptr; + + lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); + if (!process_sp) + return NULL; + AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(process_sp->GetObjCLanguageRuntime()); + if (!runtime) + return NULL; + + CompilerType valobj_type(valobj_sp->GetCompilerType()); + Flags flags(valobj_type.GetTypeInfo()); + + if (flags.IsClear(eTypeIsPointer)) + { + Error error; + valobj_sp = valobj_sp->AddressOf(error); + if (error.Fail() || !valobj_sp) + return NULL; + } + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + + if (!descriptor.get() || !descriptor->IsValid()) + return NULL; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return NULL; + + if (!strcmp(class_name,"__NSArrayI")) + { + return (new NSArrayISyntheticFrontEnd(valobj_sp)); + } + else if (!strcmp(class_name,"__NSArray0")) + { + return (new NSArray0SyntheticFrontEnd(valobj_sp)); + } + else if (!strcmp(class_name,"__NSArrayM")) + { + if (runtime->GetFoundationVersion() >= 1100) + return (new NSArrayMSyntheticFrontEnd_1010(valobj_sp)); + else + return (new NSArrayMSyntheticFrontEnd_109(valobj_sp)); + } + else + { + return (new NSArrayCodeRunningSyntheticFrontEnd(valobj_sp)); + } +} + +lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()) +{} + +size_t +lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::CalculateNumChildren () +{ + uint64_t count = 0; + if (ExtractValueFromObjCExpression(m_backend, "int", "count", count)) + return count; + return 0; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + lldb::ValueObjectSP valobj_sp = CallSelectorOnObject(m_backend,"id","objectAtIndex:",idx); + if (valobj_sp) + { + valobj_sp->SetPreferredDisplayLanguage(m_backend.GetPreferredDisplayLanguage()); + valobj_sp->SetName(ConstString(idx_name.GetData())); + } + return valobj_sp; +} + +bool +lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::Update() +{ + return false; +} + +bool +lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + return 0; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp new file mode 100644 index 000000000000..e4a7425329f5 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp @@ -0,0 +1,749 @@ +//===-- NSDictionary.cpp ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +#include <mutex> + +// Other libraries and framework includes +#include "clang/AST/DeclCXX.h" + +// Project includes +#include "NSDictionary.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +std::map<ConstString, CXXFunctionSummaryFormat::Callback>& +NSDictionary_Additionals::GetAdditionalSummaries () +{ + static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map; + return g_map; +} + +std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>& +NSDictionary_Additionals::GetAdditionalSynthetics () +{ + static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> g_map; + return g_map; +} + +static CompilerType +GetLLDBNSPairType (TargetSP target_sp) +{ + CompilerType compiler_type; + + ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext(); + + if (target_ast_context) + { + ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair"); + + compiler_type = target_ast_context->GetTypeForIdentifier<clang::CXXRecordDecl>(g___lldb_autogen_nspair); + + if (!compiler_type) + { + compiler_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC); + + if (compiler_type) + { + ClangASTContext::StartTagDeclarationDefinition(compiler_type); + CompilerType id_compiler_type = target_ast_context->GetBasicType (eBasicTypeObjCID); + ClangASTContext::AddFieldToRecordType(compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0); + ClangASTContext::AddFieldToRecordType(compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0); + ClangASTContext::CompleteTagDeclarationDefinition(compiler_type); + } + } + } + return compiler_type; +} + +namespace lldb_private { + namespace formatters { + class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSDictionaryISyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + struct DataDescriptor_32 + { + uint32_t _used : 26; + uint32_t _szidx : 6; + }; + + struct DataDescriptor_64 + { + uint64_t _used : 58; + uint32_t _szidx : 6; + }; + + struct DictionaryItemDescriptor + { + lldb::addr_t key_ptr; + lldb::addr_t val_ptr; + lldb::ValueObjectSP valobj_sp; + }; + + ExecutionContextRef m_exe_ctx_ref; + uint8_t m_ptr_size; + lldb::ByteOrder m_order; + DataDescriptor_32 *m_data_32; + DataDescriptor_64 *m_data_64; + lldb::addr_t m_data_ptr; + CompilerType m_pair_type; + std::vector<DictionaryItemDescriptor> m_children; + }; + + class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSDictionaryMSyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + struct DataDescriptor_32 + { + uint32_t _used : 26; + uint32_t _kvo : 1; + uint32_t _size; + uint32_t _mutations; + uint32_t _objs_addr; + uint32_t _keys_addr; + }; + + struct DataDescriptor_64 + { + uint64_t _used : 58; + uint32_t _kvo : 1; + uint64_t _size; + uint64_t _mutations; + uint64_t _objs_addr; + uint64_t _keys_addr; + }; + + struct DictionaryItemDescriptor + { + lldb::addr_t key_ptr; + lldb::addr_t val_ptr; + lldb::ValueObjectSP valobj_sp; + }; + + ExecutionContextRef m_exe_ctx_ref; + uint8_t m_ptr_size; + lldb::ByteOrder m_order; + DataDescriptor_32 *m_data_32; + DataDescriptor_64 *m_data_64; + CompilerType m_pair_type; + std::vector<DictionaryItemDescriptor> m_children; + }; + + class NSDictionaryCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSDictionaryCodeRunningSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + }; + } // namespace formatters +} // namespace lldb_private + +template<bool name_entries> +bool +lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + static ConstString g_TypeHint("NSDictionary"); + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + bool is_64bit = (ptr_size == 8); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint64_t value = 0; + + ConstString class_name_cs = descriptor->GetClassName(); + const char* class_name = class_name_cs.GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"__NSDictionaryI")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); + } + else if (!strcmp(class_name,"__NSDictionaryM")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); + } + /*else if (!strcmp(class_name,"__NSCFDictionary")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ? 20 : 12), 4, 0, error); + if (error.Fail()) + return false; + if (is_64bit) + value &= ~0x0f1f000000000000UL; + }*/ + else + { + auto& map(NSDictionary_Additionals::GetAdditionalSummaries()); + auto iter = map.find(class_name_cs), end = map.end(); + if (iter != end) + return iter->second(valobj, stream, options); + if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) + return false; + } + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%" PRIu64 " %s%s%s", + prefix.c_str(), + value, + "key/value pair", + value == 1 ? "" : "s", + suffix.c_str()); + return true; +} + +SyntheticChildrenFrontEnd* lldb_private::formatters::NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren* synth, lldb::ValueObjectSP valobj_sp) +{ + lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); + if (!process_sp) + return NULL; + ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + if (!runtime) + return NULL; + + CompilerType valobj_type(valobj_sp->GetCompilerType()); + Flags flags(valobj_type.GetTypeInfo()); + + if (flags.IsClear(eTypeIsPointer)) + { + Error error; + valobj_sp = valobj_sp->AddressOf(error); + if (error.Fail() || !valobj_sp) + return NULL; + } + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + + if (!descriptor.get() || !descriptor->IsValid()) + return NULL; + + ConstString class_name_cs = descriptor->GetClassName(); + const char* class_name = class_name_cs.GetCString(); + + if (!class_name || !*class_name) + return NULL; + + if (!strcmp(class_name,"__NSDictionaryI")) + { + return (new NSDictionaryISyntheticFrontEnd(valobj_sp)); + } + else if (!strcmp(class_name,"__NSDictionaryM")) + { + return (new NSDictionaryMSyntheticFrontEnd(valobj_sp)); + } + else + { + auto& map(NSDictionary_Additionals::GetAdditionalSynthetics()); + auto iter = map.find(class_name_cs), end = map.end(); + if (iter != end) + return iter->second(synth, valobj_sp); + return (new NSDictionaryCodeRunningSyntheticFrontEnd(valobj_sp)); + } +} + +lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()) +{} + +size_t +lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::CalculateNumChildren () +{ + uint64_t count = 0; + if (ExtractValueFromObjCExpression(m_backend, "int", "count", count)) + return count; + return 0; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + StreamString key_fetcher_expr; + key_fetcher_expr.Printf("(id)[(NSArray*)[(id)0x%" PRIx64 " allKeys] objectAtIndex:%" PRIu64 "]", m_backend.GetPointerValue(), (uint64_t)idx); + StreamString value_fetcher_expr; + value_fetcher_expr.Printf("(id)[(id)0x%" PRIx64 " objectForKey:(%s)]",m_backend.GetPointerValue(),key_fetcher_expr.GetData()); + StreamString object_fetcher_expr; + object_fetcher_expr.Printf("struct __lldb_autogen_nspair { id key; id value; } _lldb_valgen_item; _lldb_valgen_item.key = %s; _lldb_valgen_item.value = %s; _lldb_valgen_item;",key_fetcher_expr.GetData(),value_fetcher_expr.GetData()); + lldb::ValueObjectSP child_sp; + EvaluateExpressionOptions options; + options.SetKeepInMemory(true); + options.SetLanguage(lldb::eLanguageTypeObjC_plus_plus); + options.SetResultIsInternal(true); + m_backend.GetTargetSP()->EvaluateExpression(object_fetcher_expr.GetData(), + GetViableFrame(m_backend.GetTargetSP().get()), + child_sp, + options); + if (child_sp) + child_sp->SetName(ConstString(idx_name.GetData())); + return child_sp; +} + +bool +lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::Update() +{ + return false; +} + +bool +lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + return 0; +} + +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_exe_ctx_ref(), +m_ptr_size(8), +m_order(lldb::eByteOrderInvalid), +m_data_32(NULL), +m_data_64(NULL), +m_pair_type() +{ +} + +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::~NSDictionaryISyntheticFrontEnd () +{ + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; +} + +size_t +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +size_t +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::CalculateNumChildren () +{ + if (!m_data_32 && !m_data_64) + return 0; + return (m_data_32 ? m_data_32->_used : m_data_64->_used); +} + +bool +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update() +{ + m_children.clear(); + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; + m_ptr_size = 0; + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + m_order = process_sp->GetByteOrder(); + uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; + if (m_ptr_size == 4) + { + m_data_32 = new DataDescriptor_32(); + process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); + } + else + { + m_data_64 = new DataDescriptor_64(); + process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); + } + if (error.Fail()) + return false; + m_data_ptr = data_location + m_ptr_size; + return false; +} + +bool +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + uint32_t num_children = CalculateNumChildren(); + + if (idx >= num_children) + return lldb::ValueObjectSP(); + + if (m_children.empty()) + { + // do the scan phase + lldb::addr_t key_at_idx = 0, val_at_idx = 0; + + uint32_t tries = 0; + uint32_t test_idx = 0; + + while(tries < num_children) + { + key_at_idx = m_data_ptr + (2*test_idx * m_ptr_size); + val_at_idx = key_at_idx + m_ptr_size; + ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); + if (!process_sp) + return lldb::ValueObjectSP(); + Error error; + key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + + test_idx++; + + if (!key_at_idx || !val_at_idx) + continue; + tries++; + + DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()}; + + m_children.push_back(descriptor); + } + } + + if (idx >= m_children.size()) // should never happen + return lldb::ValueObjectSP(); + + DictionaryItemDescriptor &dict_item = m_children[idx]; + if (!dict_item.valobj_sp) + { + if (!m_pair_type.IsValid()) + { + TargetSP target_sp(m_backend.GetTargetSP()); + if (!target_sp) + return ValueObjectSP(); + m_pair_type = GetLLDBNSPairType(target_sp); + } + if (!m_pair_type.IsValid()) + return ValueObjectSP(); + + DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0)); + + if (m_ptr_size == 8) + { + uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes(); + *data_ptr = dict_item.key_ptr; + *(data_ptr+1) = dict_item.val_ptr; + } + else + { + uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); + *data_ptr = dict_item.key_ptr; + *(data_ptr+1) = dict_item.val_ptr; + } + + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + DataExtractor data(buffer_sp, m_order, m_ptr_size); + dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetData(), + data, + m_exe_ctx_ref, + m_pair_type); + } + return dict_item.valobj_sp; +} + +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_exe_ctx_ref(), +m_ptr_size(8), +m_order(lldb::eByteOrderInvalid), +m_data_32(NULL), +m_data_64(NULL), +m_pair_type() +{ +} + +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd () +{ + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; +} + +size_t +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +size_t +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::CalculateNumChildren () +{ + if (!m_data_32 && !m_data_64) + return 0; + return (m_data_32 ? m_data_32->_used : m_data_64->_used); +} + +bool +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::Update() +{ + m_children.clear(); + ValueObjectSP valobj_sp = m_backend.GetSP(); + m_ptr_size = 0; + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + m_order = process_sp->GetByteOrder(); + uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; + if (m_ptr_size == 4) + { + m_data_32 = new DataDescriptor_32(); + process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); + } + else + { + m_data_64 = new DataDescriptor_64(); + process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); + } + if (error.Fail()) + return false; + return false; +} + +bool +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + lldb::addr_t m_keys_ptr = (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr); + lldb::addr_t m_values_ptr = (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr); + + uint32_t num_children = CalculateNumChildren(); + + if (idx >= num_children) + return lldb::ValueObjectSP(); + + if (m_children.empty()) + { + // do the scan phase + lldb::addr_t key_at_idx = 0, val_at_idx = 0; + + uint32_t tries = 0; + uint32_t test_idx = 0; + + while(tries < num_children) + { + key_at_idx = m_keys_ptr + (test_idx * m_ptr_size); + val_at_idx = m_values_ptr + (test_idx * m_ptr_size);; + ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); + if (!process_sp) + return lldb::ValueObjectSP(); + Error error; + key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + + test_idx++; + + if (!key_at_idx || !val_at_idx) + continue; + tries++; + + DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()}; + + m_children.push_back(descriptor); + } + } + + if (idx >= m_children.size()) // should never happen + return lldb::ValueObjectSP(); + + DictionaryItemDescriptor &dict_item = m_children[idx]; + if (!dict_item.valobj_sp) + { + if (!m_pair_type.IsValid()) + { + TargetSP target_sp(m_backend.GetTargetSP()); + if (!target_sp) + return ValueObjectSP(); + m_pair_type = GetLLDBNSPairType(target_sp); + } + if (!m_pair_type.IsValid()) + return ValueObjectSP(); + + DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0)); + + if (m_ptr_size == 8) + { + uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes(); + *data_ptr = dict_item.key_ptr; + *(data_ptr+1) = dict_item.val_ptr; + } + else + { + uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); + *data_ptr = dict_item.key_ptr; + *(data_ptr+1) = dict_item.val_ptr; + } + + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + DataExtractor data(buffer_sp, m_order, m_ptr_size); + dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetData(), + data, + m_exe_ctx_ref, + m_pair_type); + } + return dict_item.valobj_sp; +} + +template bool +lldb_private::formatters::NSDictionarySummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&); + +template bool +lldb_private::formatters::NSDictionarySummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&); diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.h new file mode 100644 index 000000000000..e96c25a97b2b --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.h @@ -0,0 +1,48 @@ +//===-- NSDictionary.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_NSDictionary_h_ +#define liblldb_NSDictionary_h_ + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +#include <map> + +namespace lldb_private { + namespace formatters + { + template<bool name_entries> + bool + NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + extern template bool + NSDictionarySummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ; + + extern template bool + NSDictionarySummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ; + + SyntheticChildrenFrontEnd* NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + class NSDictionary_Additionals + { + public: + static std::map<ConstString, CXXFunctionSummaryFormat::Callback>& + GetAdditionalSummaries (); + + static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>& + GetAdditionalSynthetics (); + }; + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_NSDictionary_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSError.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSError.cpp new file mode 100644 index 000000000000..c627cd031926 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSError.cpp @@ -0,0 +1,218 @@ +//===-- NSError.cpp ---------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +#include "clang/AST/DeclCXX.h" + +// Project includes +#include "Cocoa.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Target.h" + +#include "lldb/Utility/ProcessStructReader.h" + +#include "Plugins/Language/ObjC/NSString.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::NSError_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp(valobj.GetProcessSP()); + if (!process_sp) + return false; + + lldb::addr_t ptr_value = LLDB_INVALID_ADDRESS; + + CompilerType valobj_type(valobj.GetCompilerType()); + Flags type_flags(valobj_type.GetTypeInfo()); + if (type_flags.AllClear(eTypeHasValue)) + { + if (valobj.IsBaseClass() && valobj.GetParent()) + ptr_value = valobj.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + } + else + ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + + if (ptr_value == LLDB_INVALID_ADDRESS) + return false; + size_t ptr_size = process_sp->GetAddressByteSize(); + lldb::addr_t code_location = ptr_value + 2 * ptr_size; + lldb::addr_t domain_location = ptr_value + 3 * ptr_size; + + Error error; + uint64_t code = process_sp->ReadUnsignedIntegerFromMemory(code_location, ptr_size, 0, error); + if (error.Fail()) + return false; + + lldb::addr_t domain_str_value = process_sp->ReadPointerFromMemory(domain_location, error); + if (error.Fail() || domain_str_value == LLDB_INVALID_ADDRESS) + return false; + + if (!domain_str_value) + { + stream.Printf("domain: nil - code: %" PRIu64, code); + return true; + } + + InferiorSizedWord isw(domain_str_value, *process_sp); + + ValueObjectSP domain_str_sp = ValueObject::CreateValueObjectFromData("domain_str", isw.GetAsData(process_sp->GetByteOrder()), valobj.GetExecutionContextRef(), process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()); + + if (!domain_str_sp) + return false; + + StreamString domain_str_summary; + if (NSStringSummaryProvider(*domain_str_sp, domain_str_summary, options) && !domain_str_summary.Empty()) + { + stream.Printf("domain: %s - code: %" PRIu64, domain_str_summary.GetData(), code); + return true; + } + else + { + stream.Printf("domain: nil - code: %" PRIu64, code); + return true; + } +} + +class NSErrorSyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + NSErrorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd(*valobj_sp) + {} + + ~NSErrorSyntheticFrontEnd() override = default; + // no need to delete m_child_ptr - it's kept alive by the cluster manager on our behalf + + size_t + CalculateNumChildren() override + { + if (m_child_ptr) + return 1; + if (m_child_sp) + return 1; + return 0; + } + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override + { + if (idx != 0) + return lldb::ValueObjectSP(); + + if (m_child_ptr) + return m_child_ptr->GetSP(); + return m_child_sp; + } + + bool + Update() override + { + m_child_ptr = nullptr; + m_child_sp.reset(); + + ProcessSP process_sp(m_backend.GetProcessSP()); + if (!process_sp) + return false; + + lldb::addr_t userinfo_location = LLDB_INVALID_ADDRESS; + + CompilerType valobj_type(m_backend.GetCompilerType()); + Flags type_flags(valobj_type.GetTypeInfo()); + if (type_flags.AllClear(eTypeHasValue)) + { + if (m_backend.IsBaseClass() && m_backend.GetParent()) + userinfo_location = m_backend.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + } + else + userinfo_location = m_backend.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + + if (userinfo_location == LLDB_INVALID_ADDRESS) + return false; + + size_t ptr_size = process_sp->GetAddressByteSize(); + + userinfo_location += 4 * ptr_size; + Error error; + lldb::addr_t userinfo = process_sp->ReadPointerFromMemory(userinfo_location, error); + if (userinfo == LLDB_INVALID_ADDRESS || error.Fail()) + return false; + InferiorSizedWord isw(userinfo,*process_sp); + m_child_sp = ValueObject::CreateValueObjectFromData("_userInfo", + isw.GetAsData(process_sp->GetByteOrder()), + m_backend.GetExecutionContextRef(), + process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); + return false; + } + + bool + MightHaveChildren() override + { + return true; + } + + size_t + GetIndexOfChildWithName(const ConstString &name) override + { + static ConstString g___userInfo("_userInfo"); + if (name == g___userInfo) + return 0; + return UINT32_MAX; + } + +private: + // the child here can be "real" (i.e. an actual child of the root) or synthetized from raw memory + // if the former, I need to store a plain pointer to it - or else a loop of references will cause this entire hierarchy of values to leak + // if the latter, then I need to store a SharedPointer to it - so that it only goes away when everyone else in the cluster goes away + // oh joy! + ValueObject* m_child_ptr; + ValueObjectSP m_child_sp; +}; + +SyntheticChildrenFrontEnd* +lldb_private::formatters::NSErrorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); + if (!process_sp) + return nullptr; + ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + if (!runtime) + return nullptr; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + + if (!descriptor.get() || !descriptor->IsValid()) + return nullptr; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return nullptr; + + if (!strcmp(class_name,"NSError")) + return (new NSErrorSyntheticFrontEnd(valobj_sp)); + else if (!strcmp(class_name,"__NSCFError")) + return (new NSErrorSyntheticFrontEnd(valobj_sp)); + + return nullptr; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSException.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSException.cpp new file mode 100644 index 000000000000..e58223a4d461 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSException.cpp @@ -0,0 +1,219 @@ +//===-- NSException.cpp -----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +#include "clang/AST/DeclCXX.h" + +// Project includes +#include "Cocoa.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Target.h" + +#include "lldb/Utility/ProcessStructReader.h" + +#include "Plugins/Language/ObjC/NSString.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +bool +lldb_private::formatters::NSException_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp(valobj.GetProcessSP()); + if (!process_sp) + return false; + + lldb::addr_t ptr_value = LLDB_INVALID_ADDRESS; + + CompilerType valobj_type(valobj.GetCompilerType()); + Flags type_flags(valobj_type.GetTypeInfo()); + if (type_flags.AllClear(eTypeHasValue)) + { + if (valobj.IsBaseClass() && valobj.GetParent()) + ptr_value = valobj.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + } + else + ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + + if (ptr_value == LLDB_INVALID_ADDRESS) + return false; + size_t ptr_size = process_sp->GetAddressByteSize(); + lldb::addr_t name_location = ptr_value + 1 * ptr_size; + lldb::addr_t reason_location = ptr_value + 2 * ptr_size; + + Error error; + lldb::addr_t name = process_sp->ReadPointerFromMemory(name_location, error); + if (error.Fail() || name == LLDB_INVALID_ADDRESS) + return false; + + lldb::addr_t reason = process_sp->ReadPointerFromMemory(reason_location, error); + if (error.Fail() || reason == LLDB_INVALID_ADDRESS) + return false; + + InferiorSizedWord name_isw(name, *process_sp); + InferiorSizedWord reason_isw(reason, *process_sp); + + CompilerType voidstar = process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeVoid).GetPointerType(); + + ValueObjectSP name_sp = ValueObject::CreateValueObjectFromData("name_str", name_isw.GetAsData(process_sp->GetByteOrder()), valobj.GetExecutionContextRef(), voidstar); + ValueObjectSP reason_sp = ValueObject::CreateValueObjectFromData("reason_str", reason_isw.GetAsData(process_sp->GetByteOrder()), valobj.GetExecutionContextRef(), voidstar); + + if (!name_sp || !reason_sp) + return false; + + StreamString name_str_summary; + StreamString reason_str_summary; + if (NSStringSummaryProvider(*name_sp, name_str_summary, options) && + NSStringSummaryProvider(*reason_sp, reason_str_summary, options) && + !name_str_summary.Empty() && + !reason_str_summary.Empty()) + { + stream.Printf("name: %s - reason: %s", name_str_summary.GetData(), reason_str_summary.GetData()); + return true; + } + else + return false; +} + +class NSExceptionSyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + NSExceptionSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd(*valobj_sp) + {} + + ~NSExceptionSyntheticFrontEnd() override = default; + // no need to delete m_child_ptr - it's kept alive by the cluster manager on our behalf + + size_t + CalculateNumChildren() override + { + if (m_child_ptr) + return 1; + if (m_child_sp) + return 1; + return 0; + } + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override + { + if (idx != 0) + return lldb::ValueObjectSP(); + + if (m_child_ptr) + return m_child_ptr->GetSP(); + return m_child_sp; + } + + bool + Update() override + { + m_child_ptr = nullptr; + m_child_sp.reset(); + + ProcessSP process_sp(m_backend.GetProcessSP()); + if (!process_sp) + return false; + + lldb::addr_t userinfo_location = LLDB_INVALID_ADDRESS; + + CompilerType valobj_type(m_backend.GetCompilerType()); + Flags type_flags(valobj_type.GetTypeInfo()); + if (type_flags.AllClear(eTypeHasValue)) + { + if (m_backend.IsBaseClass() && m_backend.GetParent()) + userinfo_location = m_backend.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + } + else + userinfo_location = m_backend.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + + if (userinfo_location == LLDB_INVALID_ADDRESS) + return false; + + size_t ptr_size = process_sp->GetAddressByteSize(); + + userinfo_location += 3 * ptr_size; + Error error; + lldb::addr_t userinfo = process_sp->ReadPointerFromMemory(userinfo_location, error); + if (userinfo == LLDB_INVALID_ADDRESS || error.Fail()) + return false; + InferiorSizedWord isw(userinfo,*process_sp); + m_child_sp = ValueObject::CreateValueObjectFromData("userInfo", + isw.GetAsData(process_sp->GetByteOrder()), + m_backend.GetExecutionContextRef(), + process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); + return false; + } + + bool + MightHaveChildren() override + { + return true; + } + + size_t + GetIndexOfChildWithName(const ConstString &name) override + { + static ConstString g___userInfo("userInfo"); + if (name == g___userInfo) + return 0; + return UINT32_MAX; + } + +private: + // the child here can be "real" (i.e. an actual child of the root) or synthetized from raw memory + // if the former, I need to store a plain pointer to it - or else a loop of references will cause this entire hierarchy of values to leak + // if the latter, then I need to store a SharedPointer to it - so that it only goes away when everyone else in the cluster goes away + // oh joy! + ValueObject* m_child_ptr; + ValueObjectSP m_child_sp; +}; + +SyntheticChildrenFrontEnd* +lldb_private::formatters::NSExceptionSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); + if (!process_sp) + return nullptr; + ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + if (!runtime) + return nullptr; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + + if (!descriptor.get() || !descriptor->IsValid()) + return nullptr; + + const char* class_name = descriptor->GetClassName().GetCString(); + + if (!class_name || !*class_name) + return nullptr; + + if (!strcmp(class_name,"NSException")) + return (new NSExceptionSyntheticFrontEnd(valobj_sp)); + else if (!strcmp(class_name,"NSCFException")) + return (new NSExceptionSyntheticFrontEnd(valobj_sp)); + else if (!strcmp(class_name,"__NSCFException")) + return (new NSExceptionSyntheticFrontEnd(valobj_sp)); + + return nullptr; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp new file mode 100644 index 000000000000..245f6da80c7f --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp @@ -0,0 +1,349 @@ +//===-- NSIndexPath.cpp -----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "Cocoa.h" + +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/TypeSynthetic.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +class NSIndexPathSyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + NSIndexPathSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd (*valobj_sp.get()), + m_ptr_size(0), + m_uint_star_type() + { + m_ptr_size = m_backend.GetTargetSP()->GetArchitecture().GetAddressByteSize(); + } + + ~NSIndexPathSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override + { + return m_impl.GetNumIndexes(); + } + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override + { + return m_impl.GetIndexAtIndex(idx, m_uint_star_type); + } + + bool + Update() override + { + m_impl.Clear(); + + TypeSystem* type_system = m_backend.GetCompilerType().GetTypeSystem(); + if (!type_system) + return false; + + ClangASTContext *ast = m_backend.GetExecutionContextRef().GetTargetSP()->GetScratchClangASTContext(); + if (!ast) + return false; + + m_uint_star_type = ast->GetPointerSizedIntType(false); + + static ConstString g__indexes("_indexes"); + static ConstString g__length("_length"); + + ProcessSP process_sp = m_backend.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(m_backend)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint64_t info_bits(0),value_bits(0),payload(0); + + if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits, &payload)) + { + m_impl.m_inlined.SetIndexes(payload, *process_sp); + m_impl.m_mode = Mode::Inlined; + } + else + { + ObjCLanguageRuntime::ClassDescriptor::iVarDescriptor _indexes_id; + ObjCLanguageRuntime::ClassDescriptor::iVarDescriptor _length_id; + + bool has_indexes(false),has_length(false); + + for (size_t x = 0; + x < descriptor->GetNumIVars(); + x++) + { + const auto& ivar = descriptor->GetIVarAtIndex(x); + if (ivar.m_name == g__indexes) + { + _indexes_id = ivar; + has_indexes = true; + } + else if (ivar.m_name == g__length) + { + _length_id = ivar; + has_length = true; + } + + if (has_length && has_indexes) + break; + } + + if (has_length && has_indexes) + { + m_impl.m_outsourced.m_indexes = m_backend.GetSyntheticChildAtOffset(_indexes_id.m_offset, + m_uint_star_type.GetPointerType(), + true).get(); + ValueObjectSP length_sp(m_backend.GetSyntheticChildAtOffset(_length_id.m_offset, + m_uint_star_type, + true)); + if (length_sp) + { + m_impl.m_outsourced.m_count = length_sp->GetValueAsUnsigned(0); + if (m_impl.m_outsourced.m_indexes) + m_impl.m_mode = Mode::Outsourced; + } + } + } + return false; + } + + bool + MightHaveChildren() override + { + if (m_impl.m_mode == Mode::Invalid) + return false; + return true; + } + + size_t + GetIndexOfChildWithName(const ConstString &name) override + { + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; + } + + lldb::ValueObjectSP + GetSyntheticValue() override + { + return nullptr; + } + +protected: + ObjCLanguageRuntime::ClassDescriptorSP m_descriptor_sp; + + enum class Mode { + Inlined, + Outsourced, + Invalid + }; + + struct Impl { + Mode m_mode; + + size_t + GetNumIndexes () + { + switch (m_mode) + { + case Mode::Inlined: + return m_inlined.GetNumIndexes(); + case Mode::Outsourced: + return m_outsourced.m_count; + default: + return 0; + } + } + + lldb::ValueObjectSP + GetIndexAtIndex (size_t idx, const CompilerType& desired_type) + { + if (idx >= GetNumIndexes()) + return nullptr; + switch (m_mode) + { + default: return nullptr; + case Mode::Inlined: + return m_inlined.GetIndexAtIndex (idx, desired_type); + case Mode::Outsourced: + return m_outsourced.GetIndexAtIndex (idx); + } + } + + struct InlinedIndexes { + public: + void SetIndexes(uint64_t value, Process& p) + { + m_indexes = value; + _lengthForInlinePayload(p.GetAddressByteSize()); + m_process = &p; + } + + size_t + GetNumIndexes () + { + return m_count; + } + + lldb::ValueObjectSP + GetIndexAtIndex (size_t idx, const CompilerType& desired_type) + { + std::pair<uint64_t, bool> value(_indexAtPositionForInlinePayload(idx)); + if (!value.second) + return nullptr; + + Value v; + if (m_ptr_size == 8) + { + Scalar scalar( (unsigned long long)value.first ); + v = Value(scalar); + } + else + { + Scalar scalar( (unsigned int)value.first ); + v = Value(scalar); + } + + v.SetCompilerType(desired_type); + + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + + return ValueObjectConstResult::Create(m_process, v, ConstString(idx_name.GetData())); + } + + void + Clear () + { + m_indexes = 0; + m_count = 0; + m_ptr_size = 0; + m_process = nullptr; + } + + private: + uint64_t m_indexes; + size_t m_count; + uint32_t m_ptr_size; + Process *m_process; + + // cfr. Foundation for the details of this code + size_t _lengthForInlinePayload(uint32_t ptr_size) { + m_ptr_size = ptr_size; + if (m_ptr_size == 8) + m_count = ((m_indexes >> 3) & 0x7); + else + m_count = ((m_indexes >> 3) & 0x3); + return m_count; + } + + std::pair<uint64_t, bool> + _indexAtPositionForInlinePayload(size_t pos) + { + if (m_ptr_size == 8) + { + switch (pos) { + case 5: return {((m_indexes >> 51) & 0x1ff),true}; + case 4: return {((m_indexes >> 42) & 0x1ff),true}; + case 3: return {((m_indexes >> 33) & 0x1ff),true}; + case 2: return {((m_indexes >> 24) & 0x1ff),true}; + case 1: return {((m_indexes >> 15) & 0x1ff),true}; + case 0: return {((m_indexes >> 6) & 0x1ff),true}; + } + } + else + { + switch (pos) { + case 2: return {((m_indexes >> 23) & 0x1ff),true}; + case 1: return {((m_indexes >> 14) & 0x1ff),true}; + case 0: return {((m_indexes >> 5) & 0x1ff),true}; + } + } + return {0,false}; + } + + }; + struct OutsourcedIndexes { + ValueObject *m_indexes; + size_t m_count; + + lldb::ValueObjectSP + GetIndexAtIndex (size_t idx) + { + if (m_indexes) + { + ValueObjectSP index_sp(m_indexes->GetSyntheticArrayMember(idx, true)); + return index_sp; + } + return nullptr; + } + + void + Clear () + { + m_indexes = nullptr; + m_count = 0; + } + }; + + union { + struct InlinedIndexes m_inlined; + struct OutsourcedIndexes m_outsourced; + }; + + void + Clear () + { + m_mode = Mode::Invalid; + m_inlined.Clear(); + m_outsourced.Clear(); + } + } m_impl; + + uint32_t m_ptr_size; + CompilerType m_uint_star_type; +}; + +namespace lldb_private { + namespace formatters { + + SyntheticChildrenFrontEnd* NSIndexPathSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) + { + if (valobj_sp) + return new NSIndexPathSyntheticFrontEnd(valobj_sp); + return nullptr; + } + + } // namespace formatters +} // namespace lldb_private diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.cpp new file mode 100644 index 000000000000..93115957e329 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.cpp @@ -0,0 +1,758 @@ +//===-- NSSet.cpp -----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "NSSet.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +std::map<ConstString, CXXFunctionSummaryFormat::Callback>& +NSSet_Additionals::GetAdditionalSummaries () +{ + static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map; + return g_map; +} + +std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>& +NSSet_Additionals::GetAdditionalSynthetics () +{ + static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> g_map; + return g_map; +} + +namespace lldb_private { + namespace formatters { + class NSSetISyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSSetISyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + struct DataDescriptor_32 + { + uint32_t _used : 26; + uint32_t _szidx : 6; + }; + + struct DataDescriptor_64 + { + uint64_t _used : 58; + uint32_t _szidx : 6; + }; + + struct SetItemDescriptor + { + lldb::addr_t item_ptr; + lldb::ValueObjectSP valobj_sp; + }; + + ExecutionContextRef m_exe_ctx_ref; + uint8_t m_ptr_size; + DataDescriptor_32 *m_data_32; + DataDescriptor_64 *m_data_64; + lldb::addr_t m_data_ptr; + std::vector<SetItemDescriptor> m_children; + }; + + class NSOrderedSetSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSOrderedSetSyntheticFrontEnd() override = default; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + uint32_t m_count; + std::map<uint32_t,lldb::ValueObjectSP> m_children; + }; + + class NSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSSetMSyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + + private: + struct DataDescriptor_32 + { + uint32_t _used : 26; + uint32_t _size; + uint32_t _mutations; + uint32_t _objs_addr; + }; + + struct DataDescriptor_64 + { + uint64_t _used : 58; + uint64_t _size; + uint64_t _mutations; + uint64_t _objs_addr; + }; + + struct SetItemDescriptor + { + lldb::addr_t item_ptr; + lldb::ValueObjectSP valobj_sp; + }; + + ExecutionContextRef m_exe_ctx_ref; + uint8_t m_ptr_size; + DataDescriptor_32 *m_data_32; + DataDescriptor_64 *m_data_64; + std::vector<SetItemDescriptor> m_children; + }; + + class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSSetCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSSetCodeRunningSyntheticFrontEnd() override; + + size_t + CalculateNumChildren() override; + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override; + + bool + Update() override; + + bool + MightHaveChildren() override; + + size_t + GetIndexOfChildWithName(const ConstString &name) override; + }; + } // namespace formatters +} // namespace lldb_private + +template<bool cf_style> +bool +lldb_private::formatters::NSSetSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + static ConstString g_TypeHint("NSSet"); + + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + bool is_64bit = (ptr_size == 8); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + uint64_t value = 0; + + ConstString class_name_cs = descriptor->GetClassName(); + const char* class_name = class_name_cs.GetCString(); + + if (!class_name || !*class_name) + return false; + + if (!strcmp(class_name,"__NSSetI")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); + } + else if (!strcmp(class_name,"__NSSetM")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); + } + /*else if (!strcmp(class_name,"__NSCFSet")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ? 20 : 12), 4, 0, error); + if (error.Fail()) + return false; + if (is_64bit) + value &= ~0x1fff000000000000UL; + } + else if (!strcmp(class_name,"NSCountedSet")) + { + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); + if (error.Fail()) + return false; + value = process_sp->ReadUnsignedIntegerFromMemory(value + (is_64bit ? 20 : 12), 4, 0, error); + if (error.Fail()) + return false; + if (is_64bit) + value &= ~0x1fff000000000000UL; + }*/ + else + { + auto& map(NSSet_Additionals::GetAdditionalSummaries()); + auto iter = map.find(class_name_cs), end = map.end(); + if (iter != end) + return iter->second(valobj, stream, options); + if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) + return false; + } + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + stream.Printf("%s%" PRIu64 " %s%s%s", + prefix.c_str(), + value, + "element", + value == 1 ? "" : "s", + suffix.c_str()); + return true; +} + +SyntheticChildrenFrontEnd* lldb_private::formatters::NSSetSyntheticFrontEndCreator (CXXSyntheticChildren* synth, lldb::ValueObjectSP valobj_sp) +{ + lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); + if (!process_sp) + return NULL; + ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + if (!runtime) + return NULL; + + CompilerType valobj_type(valobj_sp->GetCompilerType()); + Flags flags(valobj_type.GetTypeInfo()); + + if (flags.IsClear(eTypeIsPointer)) + { + Error error; + valobj_sp = valobj_sp->AddressOf(error); + if (error.Fail() || !valobj_sp) + return NULL; + } + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + + if (!descriptor.get() || !descriptor->IsValid()) + return NULL; + + ConstString class_name_cs = descriptor->GetClassName(); + const char* class_name = class_name_cs.GetCString(); + + if (!class_name || !*class_name) + return NULL; + + if (!strcmp(class_name,"__NSSetI")) + { + return (new NSSetISyntheticFrontEnd(valobj_sp)); + } + else if (!strcmp(class_name,"__NSSetM")) + { + return (new NSSetMSyntheticFrontEnd(valobj_sp)); + } + else if ((!strcmp(class_name,"__NSOrderedSetI")) || (!strcmp(class_name,"__NSOrderedSetM"))) + { + return new NSOrderedSetSyntheticFrontEnd(valobj_sp); // this runs code + } + else + { + auto& map(NSSet_Additionals::GetAdditionalSynthetics()); + auto iter = map.find(class_name_cs), end = map.end(); + if (iter != end) + return iter->second(synth, valobj_sp); + return /*(new NSSetCodeRunningSyntheticFrontEnd(valobj_sp))*/ NULL; + } +} + +lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_exe_ctx_ref(), +m_ptr_size(8), +m_data_32(NULL), +m_data_64(NULL) +{ + if (valobj_sp) + Update(); +} + +lldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd () +{ + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; +} + +size_t +lldb_private::formatters::NSSetISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +size_t +lldb_private::formatters::NSSetISyntheticFrontEnd::CalculateNumChildren () +{ + if (!m_data_32 && !m_data_64) + return 0; + return (m_data_32 ? m_data_32->_used : m_data_64->_used); +} + +bool +lldb_private::formatters::NSSetISyntheticFrontEnd::Update() +{ + m_children.clear(); + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; + m_ptr_size = 0; + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + if (valobj_sp->IsPointerType()) + { + valobj_sp = valobj_sp->Dereference(error); + if (error.Fail() || !valobj_sp) + return false; + } + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + uint64_t data_location = valobj_sp->GetAddressOf() + m_ptr_size; + if (m_ptr_size == 4) + { + m_data_32 = new DataDescriptor_32(); + process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); + } + else + { + m_data_64 = new DataDescriptor_64(); + process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); + } + if (error.Fail()) + return false; + m_data_ptr = data_location + m_ptr_size; + return false; +} + +bool +lldb_private::formatters::NSSetISyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSSetISyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + uint32_t num_children = CalculateNumChildren(); + + if (idx >= num_children) + return lldb::ValueObjectSP(); + + ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); + if (!process_sp) + return lldb::ValueObjectSP(); + + if (m_children.empty()) + { + // do the scan phase + lldb::addr_t obj_at_idx = 0; + + uint32_t tries = 0; + uint32_t test_idx = 0; + + while(tries < num_children) + { + obj_at_idx = m_data_ptr + (test_idx * m_ptr_size); + if (!process_sp) + return lldb::ValueObjectSP(); + Error error; + obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + + test_idx++; + + if (!obj_at_idx) + continue; + tries++; + + SetItemDescriptor descriptor = {obj_at_idx,lldb::ValueObjectSP()}; + + m_children.push_back(descriptor); + } + } + + if (idx >= m_children.size()) // should never happen + return lldb::ValueObjectSP(); + + SetItemDescriptor &set_item = m_children[idx]; + if (!set_item.valobj_sp) + { + auto ptr_size = process_sp->GetAddressByteSize(); + DataBufferHeap buffer(ptr_size,0); + switch (ptr_size) + { + case 0: // architecture has no clue?? - fail + return lldb::ValueObjectSP(); + case 4: + *((uint32_t*)buffer.GetBytes()) = (uint32_t)set_item.item_ptr; + break; + case 8: + *((uint64_t*)buffer.GetBytes()) = (uint64_t)set_item.item_ptr; + break; + default: + assert(false && "pointer size is not 4 nor 8 - get out of here ASAP"); + } + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + + DataExtractor data(buffer.GetBytes(), + buffer.GetByteSize(), + process_sp->GetByteOrder(), + process_sp->GetAddressByteSize()); + + set_item.valobj_sp = + CreateValueObjectFromData(idx_name.GetData(), + data, + m_exe_ctx_ref, + m_backend.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID)); + } + return set_item.valobj_sp; +} + +lldb_private::formatters::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_exe_ctx_ref(), +m_ptr_size(8), +m_data_32(NULL), +m_data_64(NULL) +{ + if (valobj_sp) + Update (); +} + +lldb_private::formatters::NSSetMSyntheticFrontEnd::~NSSetMSyntheticFrontEnd () +{ + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; +} + +size_t +lldb_private::formatters::NSSetMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +size_t +lldb_private::formatters::NSSetMSyntheticFrontEnd::CalculateNumChildren () +{ + if (!m_data_32 && !m_data_64) + return 0; + return (m_data_32 ? m_data_32->_used : m_data_64->_used); +} + +bool +lldb_private::formatters::NSSetMSyntheticFrontEnd::Update() +{ + m_children.clear(); + ValueObjectSP valobj_sp = m_backend.GetSP(); + m_ptr_size = 0; + delete m_data_32; + m_data_32 = NULL; + delete m_data_64; + m_data_64 = NULL; + if (!valobj_sp) + return false; + if (!valobj_sp) + return false; + m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); + Error error; + if (valobj_sp->IsPointerType()) + { + valobj_sp = valobj_sp->Dereference(error); + if (error.Fail() || !valobj_sp) + return false; + } + error.Clear(); + lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); + if (!process_sp) + return false; + m_ptr_size = process_sp->GetAddressByteSize(); + uint64_t data_location = valobj_sp->GetAddressOf() + m_ptr_size; + if (m_ptr_size == 4) + { + m_data_32 = new DataDescriptor_32(); + process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); + } + else + { + m_data_64 = new DataDescriptor_64(); + process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); + } + if (error.Fail()) + return false; + return false; +} + +bool +lldb_private::formatters::NSSetMSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSSetMSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + lldb::addr_t m_objs_addr = (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr); + + uint32_t num_children = CalculateNumChildren(); + + if (idx >= num_children) + return lldb::ValueObjectSP(); + + ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); + if (!process_sp) + return lldb::ValueObjectSP(); + + if (m_children.empty()) + { + // do the scan phase + lldb::addr_t obj_at_idx = 0; + + uint32_t tries = 0; + uint32_t test_idx = 0; + + while(tries < num_children) + { + obj_at_idx = m_objs_addr + (test_idx * m_ptr_size); + if (!process_sp) + return lldb::ValueObjectSP(); + Error error; + obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error); + if (error.Fail()) + return lldb::ValueObjectSP(); + + test_idx++; + + if (!obj_at_idx) + continue; + tries++; + + SetItemDescriptor descriptor = {obj_at_idx,lldb::ValueObjectSP()}; + + m_children.push_back(descriptor); + } + } + + if (idx >= m_children.size()) // should never happen + return lldb::ValueObjectSP(); + + SetItemDescriptor &set_item = m_children[idx]; + if (!set_item.valobj_sp) + { + auto ptr_size = process_sp->GetAddressByteSize(); + DataBufferHeap buffer(ptr_size,0); + switch (ptr_size) + { + case 0: // architecture has no clue?? - fail + return lldb::ValueObjectSP(); + case 4: + *((uint32_t*)buffer.GetBytes()) = (uint32_t)set_item.item_ptr; + break; + case 8: + *((uint64_t*)buffer.GetBytes()) = (uint64_t)set_item.item_ptr; + break; + default: + assert(false && "pointer size is not 4 nor 8 - get out of here ASAP"); + } + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + + DataExtractor data(buffer.GetBytes(), + buffer.GetByteSize(), + process_sp->GetByteOrder(), + process_sp->GetAddressByteSize()); + + set_item.valobj_sp = + CreateValueObjectFromData(idx_name.GetData(), + data, + m_exe_ctx_ref, + m_backend.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID)); + } + return set_item.valobj_sp; +} + +lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd(*valobj_sp.get()), +m_count(UINT32_MAX), +m_children() +{} + +size_t +lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::CalculateNumChildren () +{ + if (m_count != UINT32_MAX) + return m_count; + uint64_t count_temp; + if (ExtractValueFromObjCExpression(m_backend,"unsigned int","count",count_temp)) + return (m_count = count_temp); + return (m_count = 0); +} + +lldb::ValueObjectSP +lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + auto iter = m_children.find(idx); + if (iter == m_children.end()) + { + lldb::ValueObjectSP retval_sp; + if (idx <= m_count) + { + retval_sp = CallSelectorOnObject(m_backend, "id", "objectAtIndex", idx); + if (retval_sp) + { + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + retval_sp->SetName(ConstString(idx_name.GetData())); + } + m_children[idx] = retval_sp; + } + return retval_sp; + } + else + return iter->second; +} + +bool +lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::Update() +{ + return false; +} + +bool +lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +size_t +lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + const char* item_name = name.GetCString(); + uint32_t idx = ExtractIndexFromString(item_name); + if (idx < UINT32_MAX && idx >= CalculateNumChildren()) + return UINT32_MAX; + return idx; +} + +template bool +lldb_private::formatters::NSSetSummaryProvider<true> (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + +template bool +lldb_private::formatters::NSSetSummaryProvider<false> (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.h new file mode 100644 index 000000000000..c8622706e860 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.h @@ -0,0 +1,40 @@ +//===-- NSSet.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_NSSet_h_ +#define liblldb_NSSet_h_ + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +namespace lldb_private { + namespace formatters + { + template<bool cf_style> + bool + NSSetSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + SyntheticChildrenFrontEnd* NSSetSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + class NSSet_Additionals + { + public: + static std::map<ConstString, CXXFunctionSummaryFormat::Callback>& + GetAdditionalSummaries (); + + static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>& + GetAdditionalSynthetics (); + }; + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_NSSet_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSString.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSString.cpp new file mode 100644 index 000000000000..80896631baf3 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSString.cpp @@ -0,0 +1,405 @@ +//===-- NSString.cpp ----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "NSString.h" + +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/StringPrinter.h" +#include "lldb/Host/Endian.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/ProcessStructReader.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +std::map<ConstString, CXXFunctionSummaryFormat::Callback>& +NSString_Additionals::GetAdditionalSummaries () +{ + static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map; + return g_map; +} + +static CompilerType +GetNSPathStore2Type (Target &target) +{ + static ConstString g_type_name("__lldb_autogen_nspathstore2"); + + ClangASTContext *ast_ctx = target.GetScratchClangASTContext(); + + if (!ast_ctx) + return CompilerType(); + + CompilerType voidstar = ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType(); + CompilerType uint32 = ast_ctx->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32); + + return ast_ctx->GetOrCreateStructForIdentifier(g_type_name, { + {"isa",voidstar}, + {"lengthAndRef",uint32}, + {"buffer",voidstar} + }); +} + +bool +lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options) +{ + static ConstString g_TypeHint("NSString"); + + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); + + if (!runtime) + return false; + + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); + + if (!descriptor.get() || !descriptor->IsValid()) + return false; + + uint32_t ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); + + if (!valobj_addr) + return false; + + ConstString class_name_cs = descriptor->GetClassName(); + const char* class_name = class_name_cs.GetCString(); + + if (!class_name || !*class_name) + return false; + + bool is_tagged_ptr = (0 == strcmp(class_name,"NSTaggedPointerString")) && descriptor->GetTaggedPointerInfo(); + // for a tagged pointer, the descriptor has everything we need + if (is_tagged_ptr) + return NSTaggedString_SummaryProvider(valobj, descriptor, stream, summary_options); + + auto& additionals_map(NSString_Additionals::GetAdditionalSummaries()); + auto iter = additionals_map.find(class_name_cs), end = additionals_map.end(); + if (iter != end) + return iter->second(valobj, stream, summary_options); + + // if not a tagged pointer that we know about, try the normal route + uint64_t info_bits_location = valobj_addr + ptr_size; + if (process_sp->GetByteOrder() != lldb::eByteOrderLittle) + info_bits_location += 3; + + Error error; + + uint8_t info_bits = process_sp->ReadUnsignedIntegerFromMemory(info_bits_location, 1, 0, error); + if (error.Fail()) + return false; + + bool is_mutable = (info_bits & 1) == 1; + bool is_inline = (info_bits & 0x60) == 0; + bool has_explicit_length = (info_bits & (1 | 4)) != 4; + bool is_unicode = (info_bits & 0x10) == 0x10; + bool is_path_store = strcmp(class_name,"NSPathStore2") == 0; + bool has_null = (info_bits & 8) == 8; + + size_t explicit_length = 0; + if (!has_null && has_explicit_length && !is_path_store) + { + lldb::addr_t explicit_length_offset = 2*ptr_size; + if (is_mutable && !is_inline) + explicit_length_offset = explicit_length_offset + ptr_size; // notInlineMutable.length; + else if (is_inline) + explicit_length = explicit_length + 0; // inline1.length; + else if (!is_inline && !is_mutable) + explicit_length_offset = explicit_length_offset + ptr_size; // notInlineImmutable1.length; + else + explicit_length_offset = 0; + + if (explicit_length_offset) + { + explicit_length_offset = valobj_addr + explicit_length_offset; + explicit_length = process_sp->ReadUnsignedIntegerFromMemory(explicit_length_offset, 4, 0, error); + } + } + + if (strcmp(class_name,"NSString") && + strcmp(class_name,"CFStringRef") && + strcmp(class_name,"CFMutableStringRef") && + strcmp(class_name,"__NSCFConstantString") && + strcmp(class_name,"__NSCFString") && + strcmp(class_name,"NSCFConstantString") && + strcmp(class_name,"NSCFString") && + strcmp(class_name,"NSPathStore2")) + { + // not one of us - but tell me class name + stream.Printf("class name = %s",class_name); + return true; + } + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(summary_options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + options.SetPrefixToken(prefix); + options.SetSuffixToken(suffix); + + if (is_mutable) + { + uint64_t location = 2 * ptr_size + valobj_addr; + location = process_sp->ReadPointerFromMemory(location, error); + if (error.Fail()) + return false; + if (has_explicit_length && is_unicode) + { + options.SetLocation(location); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetQuote('"'); + options.SetSourceSize(explicit_length); + options.SetNeedsZeroTermination(false); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetBinaryZeroIsTerminator(false); + options.SetLanguage(summary_options.GetLanguage()); + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); + } + else + { + options.SetLocation(location+1); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetSourceSize(explicit_length); + options.SetNeedsZeroTermination(false); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetBinaryZeroIsTerminator(false); + options.SetLanguage(summary_options.GetLanguage()); + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::ASCII>(options); + } + } + else if (is_inline && has_explicit_length && !is_unicode && !is_path_store && !is_mutable) + { + uint64_t location = 3 * ptr_size + valobj_addr; + + options.SetLocation(location); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetQuote('"'); + options.SetSourceSize(explicit_length); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetLanguage(summary_options.GetLanguage()); + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::ASCII> (options); + } + else if (is_unicode) + { + uint64_t location = valobj_addr + 2*ptr_size; + if (is_inline) + { + if (!has_explicit_length) + { + stream.Printf("found new combo"); + return true; + } + else + location += ptr_size; + } + else + { + location = process_sp->ReadPointerFromMemory(location, error); + if (error.Fail()) + return false; + } + options.SetLocation(location); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetQuote('"'); + options.SetSourceSize(explicit_length); + options.SetNeedsZeroTermination(has_explicit_length == false); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetBinaryZeroIsTerminator(has_explicit_length == false); + options.SetLanguage(summary_options.GetLanguage()); + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16> (options); + } + else if (is_path_store) + { + ProcessStructReader reader(valobj.GetProcessSP().get(), valobj.GetValueAsUnsigned(0), GetNSPathStore2Type(*valobj.GetTargetSP())); + explicit_length = reader.GetField<uint32_t>(ConstString("lengthAndRef")) >> 20; + lldb::addr_t location = valobj.GetValueAsUnsigned(0) + ptr_size + 4; + + options.SetLocation(location); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetQuote('"'); + options.SetSourceSize(explicit_length); + options.SetNeedsZeroTermination(has_explicit_length == false); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetBinaryZeroIsTerminator(has_explicit_length == false); + options.SetLanguage(summary_options.GetLanguage()); + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16> (options); + } + else if (is_inline) + { + uint64_t location = valobj_addr + 2*ptr_size; + if (!has_explicit_length) + { + // in this kind of string, the byte before the string content is a length byte + // so let's try and use it to handle the embedded NUL case + Error error; + explicit_length = process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error); + if (error.Fail() || explicit_length == 0) + has_explicit_length = false; + else + has_explicit_length = true; + location++; + } + options.SetLocation(location); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetSourceSize(explicit_length); + options.SetNeedsZeroTermination(!has_explicit_length); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetBinaryZeroIsTerminator(!has_explicit_length); + options.SetLanguage(summary_options.GetLanguage()); + if (has_explicit_length) + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(options); + else + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::ASCII>(options); + } + else + { + uint64_t location = valobj_addr + 2*ptr_size; + location = process_sp->ReadPointerFromMemory(location, error); + if (error.Fail()) + return false; + if (has_explicit_length && !has_null) + explicit_length++; // account for the fact that there is no NULL and we need to have one added + options.SetLocation(location); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetSourceSize(explicit_length); + options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped); + options.SetLanguage(summary_options.GetLanguage()); + return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::ASCII>(options); + } +} + +bool +lldb_private::formatters::NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + TargetSP target_sp(valobj.GetTargetSP()); + if (!target_sp) + return false; + uint32_t addr_size = target_sp->GetArchitecture().GetAddressByteSize(); + uint64_t pointer_value = valobj.GetValueAsUnsigned(0); + if (!pointer_value) + return false; + pointer_value += addr_size; + CompilerType type(valobj.GetCompilerType()); + ExecutionContext exe_ctx(target_sp,false); + ValueObjectSP child_ptr_sp(valobj.CreateValueObjectFromAddress("string_ptr", pointer_value, exe_ctx, type)); + if (!child_ptr_sp) + return false; + DataExtractor data; + Error error; + child_ptr_sp->GetData(data, error); + if (error.Fail()) + return false; + ValueObjectSP child_sp(child_ptr_sp->CreateValueObjectFromData("string_data", data, exe_ctx, type)); + child_sp->GetValueAsUnsigned(0); + if (child_sp) + return NSStringSummaryProvider(*child_sp, stream, options); + return false; +} + +bool +lldb_private::formatters::NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + return NSAttributedStringSummaryProvider(valobj, stream, options); +} + +bool +lldb_private::formatters::NSTaggedString_SummaryProvider (ValueObject& valobj, ObjCLanguageRuntime::ClassDescriptorSP descriptor, Stream& stream, const TypeSummaryOptions& summary_options) +{ + static ConstString g_TypeHint("NSString"); + + if (!descriptor) + return false; + uint64_t len_bits = 0, data_bits = 0; + if (!descriptor->GetTaggedPointerInfo(&len_bits,&data_bits,nullptr)) + return false; + + static const int g_MaxNonBitmaskedLen = 7; //TAGGED_STRING_UNPACKED_MAXLEN + static const int g_SixbitMaxLen = 9; + static const int g_fiveBitMaxLen = 11; + + static const char *sixBitToCharLookup = "eilotrm.apdnsIc ufkMShjTRxgC4013" "bDNvwyUL2O856P-B79AFKEWV_zGJ/HYX"; + + if (len_bits > g_fiveBitMaxLen) + return false; + + std::string prefix,suffix; + if (Language* language = Language::FindPlugin(summary_options.GetLanguage())) + { + if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix)) + { + prefix.clear(); + suffix.clear(); + } + } + + // this is a fairly ugly trick - pretend that the numeric value is actually a char* + // this works under a few assumptions: + // little endian architecture + // sizeof(uint64_t) > g_MaxNonBitmaskedLen + if (len_bits <= g_MaxNonBitmaskedLen) + { + stream.Printf("%s",prefix.c_str()); + stream.Printf("\"%s\"",(const char*)&data_bits); + stream.Printf("%s",suffix.c_str()); + return true; + } + + // if the data is bitmasked, we need to actually process the bytes + uint8_t bitmask = 0; + uint8_t shift_offset = 0; + + if (len_bits <= g_SixbitMaxLen) + { + bitmask = 0x03f; + shift_offset = 6; + } + else + { + bitmask = 0x01f; + shift_offset = 5; + } + + std::vector<uint8_t> bytes; + bytes.resize(len_bits); + for (; len_bits > 0; data_bits >>= shift_offset, --len_bits) + { + uint8_t packed = data_bits & bitmask; + bytes.insert(bytes.begin(), sixBitToCharLookup[packed]); + } + + stream.Printf("%s",prefix.c_str()); + stream.Printf("\"%s\"",&bytes[0]); + stream.Printf("%s",suffix.c_str()); + return true; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSString.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSString.h new file mode 100644 index 000000000000..6a767a55e009 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSString.h @@ -0,0 +1,42 @@ +//===-- NSString.h ---------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_NSString_h_ +#define liblldb_NSString_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/Target/ObjCLanguageRuntime.h" + +namespace lldb_private { + namespace formatters + { + bool + NSStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSTaggedString_SummaryProvider (ValueObject& valobj, ObjCLanguageRuntime::ClassDescriptorSP descriptor, Stream& stream, const TypeSummaryOptions& summary_options); + + bool + NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + bool + NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); + + class NSString_Additionals + { + public: + static std::map<ConstString, CXXFunctionSummaryFormat::Callback>& + GetAdditionalSummaries (); + }; + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_CF_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp new file mode 100644 index 000000000000..91a3a0fb4299 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp @@ -0,0 +1,877 @@ +//===-- ObjCLanguage.cpp ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +#include <mutex> + +// Other libraries and framework includes +// Project includes +#include "ObjCLanguage.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/StreamString.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/DataVisualization.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Symbol/ClangASTContext.h" + +#include "CF.h" +#include "Cocoa.h" +#include "CoreMedia.h" +#include "NSDictionary.h" +#include "NSSet.h" +#include "NSString.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +void +ObjCLanguage::Initialize() +{ + PluginManager::RegisterPlugin (GetPluginNameStatic(), + "Objective-C Language", + CreateInstance); +} + +void +ObjCLanguage::Terminate() +{ + PluginManager::UnregisterPlugin (CreateInstance); +} + +lldb_private::ConstString +ObjCLanguage::GetPluginNameStatic() +{ + static ConstString g_name("objc"); + return g_name; +} + +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +lldb_private::ConstString +ObjCLanguage::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +ObjCLanguage::GetPluginVersion() +{ + return 1; +} + +//------------------------------------------------------------------ +// Static Functions +//------------------------------------------------------------------ +Language * +ObjCLanguage::CreateInstance (lldb::LanguageType language) +{ + switch (language) + { + case lldb::eLanguageTypeObjC: + return new ObjCLanguage(); + default: + return nullptr; + } +} + +void +ObjCLanguage::MethodName::Clear() +{ + m_full.Clear(); + m_class.Clear(); + m_category.Clear(); + m_selector.Clear(); + m_type = eTypeUnspecified; + m_category_is_valid = false; +} + +bool +ObjCLanguage::MethodName::SetName (const char *name, bool strict) +{ + Clear(); + if (name && name[0]) + { + // If "strict" is true. then the method must be specified with a + // '+' or '-' at the beginning. If "strict" is false, then the '+' + // or '-' can be omitted + bool valid_prefix = false; + + if (name[0] == '+' || name[0] == '-') + { + valid_prefix = name[1] == '['; + if (name[0] == '+') + m_type = eTypeClassMethod; + else + m_type = eTypeInstanceMethod; + } + else if (!strict) + { + // "strict" is false, the name just needs to start with '[' + valid_prefix = name[0] == '['; + } + + if (valid_prefix) + { + int name_len = strlen (name); + // Objective C methods must have at least: + // "-[" or "+[" prefix + // One character for a class name + // One character for the space between the class name + // One character for the method name + // "]" suffix + if (name_len >= (5 + (strict ? 1 : 0)) && name[name_len - 1] == ']') + { + m_full.SetCStringWithLength(name, name_len); + } + } + } + return IsValid(strict); +} + +const ConstString & +ObjCLanguage::MethodName::GetClassName () +{ + if (!m_class) + { + if (IsValid(false)) + { + const char *full = m_full.GetCString(); + const char *class_start = (full[0] == '[' ? full + 1 : full + 2); + const char *paren_pos = strchr (class_start, '('); + if (paren_pos) + { + m_class.SetCStringWithLength (class_start, paren_pos - class_start); + } + else + { + // No '(' was found in the full name, we can definitively say + // that our category was valid (and empty). + m_category_is_valid = true; + const char *space_pos = strchr (full, ' '); + if (space_pos) + { + m_class.SetCStringWithLength (class_start, space_pos - class_start); + if (!m_class_category) + { + // No category in name, so we can also fill in the m_class_category + m_class_category = m_class; + } + } + } + } + } + return m_class; +} + +const ConstString & +ObjCLanguage::MethodName::GetClassNameWithCategory () +{ + if (!m_class_category) + { + if (IsValid(false)) + { + const char *full = m_full.GetCString(); + const char *class_start = (full[0] == '[' ? full + 1 : full + 2); + const char *space_pos = strchr (full, ' '); + if (space_pos) + { + m_class_category.SetCStringWithLength (class_start, space_pos - class_start); + // If m_class hasn't been filled in and the class with category doesn't + // contain a '(', then we can also fill in the m_class + if (!m_class && strchr (m_class_category.GetCString(), '(') == NULL) + { + m_class = m_class_category; + // No '(' was found in the full name, we can definitively say + // that our category was valid (and empty). + m_category_is_valid = true; + + } + } + } + } + return m_class_category; +} + +const ConstString & +ObjCLanguage::MethodName::GetSelector () +{ + if (!m_selector) + { + if (IsValid(false)) + { + const char *full = m_full.GetCString(); + const char *space_pos = strchr (full, ' '); + if (space_pos) + { + ++space_pos; // skip the space + m_selector.SetCStringWithLength (space_pos, m_full.GetLength() - (space_pos - full) - 1); + } + } + } + return m_selector; +} + +const ConstString & +ObjCLanguage::MethodName::GetCategory () +{ + if (!m_category_is_valid && !m_category) + { + if (IsValid(false)) + { + m_category_is_valid = true; + const char *full = m_full.GetCString(); + const char *class_start = (full[0] == '[' ? full + 1 : full + 2); + const char *open_paren_pos = strchr (class_start, '('); + if (open_paren_pos) + { + ++open_paren_pos; // Skip the open paren + const char *close_paren_pos = strchr (open_paren_pos, ')'); + if (close_paren_pos) + m_category.SetCStringWithLength (open_paren_pos, close_paren_pos - open_paren_pos); + } + } + } + return m_category; +} + +ConstString +ObjCLanguage::MethodName::GetFullNameWithoutCategory (bool empty_if_no_category) +{ + if (IsValid(false)) + { + if (HasCategory()) + { + StreamString strm; + if (m_type == eTypeClassMethod) + strm.PutChar('+'); + else if (m_type == eTypeInstanceMethod) + strm.PutChar('-'); + strm.Printf("[%s %s]", GetClassName().GetCString(), GetSelector().GetCString()); + return ConstString(strm.GetString().c_str()); + } + + if (!empty_if_no_category) + { + // Just return the full name since it doesn't have a category + return GetFullName(); + } + } + return ConstString(); +} + +size_t +ObjCLanguage::MethodName::GetFullNames (std::vector<ConstString> &names, bool append) +{ + if (!append) + names.clear(); + if (IsValid(false)) + { + StreamString strm; + const bool is_class_method = m_type == eTypeClassMethod; + const bool is_instance_method = m_type == eTypeInstanceMethod; + const ConstString &category = GetCategory(); + if (is_class_method || is_instance_method) + { + names.push_back (m_full); + if (category) + { + strm.Printf("%c[%s %s]", + is_class_method ? '+' : '-', + GetClassName().GetCString(), + GetSelector().GetCString()); + names.push_back(ConstString(strm.GetString().c_str())); + } + } + else + { + const ConstString &class_name = GetClassName(); + const ConstString &selector = GetSelector(); + strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString()); + names.push_back(ConstString(strm.GetString().c_str())); + strm.Clear(); + strm.Printf("-[%s %s]", class_name.GetCString(), selector.GetCString()); + names.push_back(ConstString(strm.GetString().c_str())); + strm.Clear(); + if (category) + { + strm.Printf("+[%s(%s) %s]", class_name.GetCString(), category.GetCString(), selector.GetCString()); + names.push_back(ConstString(strm.GetString().c_str())); + strm.Clear(); + strm.Printf("-[%s(%s) %s]", class_name.GetCString(), category.GetCString(), selector.GetCString()); + names.push_back(ConstString(strm.GetString().c_str())); + } + } + } + return names.size(); +} + +static void +LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) +{ + if (!objc_category_sp) + return; + + TypeSummaryImpl::Flags objc_flags; + objc_flags.SetCascades(false) + .SetSkipPointers(true) + .SetSkipReferences(true) + .SetDontShowChildren(true) + .SetDontShowValue(true) + .SetShowMembersOneLiner(false) + .SetHideItemNames(false); + + lldb::TypeSummaryImplSP ObjC_BOOL_summary(new CXXFunctionSummaryFormat(objc_flags, lldb_private::formatters::ObjCBOOLSummaryProvider,"")); + objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL"), + ObjC_BOOL_summary); + objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL &"), + ObjC_BOOL_summary); + objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL *"), + ObjC_BOOL_summary); + +#ifndef LLDB_DISABLE_PYTHON + // we need to skip pointers here since we are special casing a SEL* when retrieving its value + objc_flags.SetSkipPointers(true); + AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("SEL"), objc_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("struct objc_selector"), objc_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("objc_selector"), objc_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("objc_selector *"), objc_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("SEL *"), objc_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCClassSummaryProvider, "Class summary provider", ConstString("Class"), objc_flags); + + SyntheticChildren::Flags class_synth_flags; + class_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false); + + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::ObjCClassSyntheticFrontEndCreator, "Class synthetic children", ConstString("Class"), class_synth_flags); +#endif // LLDB_DISABLE_PYTHON + + objc_flags.SetSkipPointers(false); + objc_flags.SetCascades(true); + objc_flags.SetSkipReferences(false); + + AddStringSummary (objc_category_sp, + "${var.__FuncPtr%A}", + ConstString("__block_literal_generic"), + objc_flags); + + AddStringSummary(objc_category_sp, + "${var.years} years, ${var.months} months, ${var.days} days, ${var.hours} hours, ${var.minutes} minutes ${var.seconds} seconds", + ConstString("CFGregorianUnits"), + objc_flags); + AddStringSummary(objc_category_sp, + "location=${var.location} length=${var.length}", + ConstString("CFRange"), + objc_flags); + + AddStringSummary(objc_category_sp, + "location=${var.location}, length=${var.length}", + ConstString("NSRange"), + objc_flags); + AddStringSummary(objc_category_sp, + "(${var.origin}, ${var.size}), ...", + ConstString("NSRectArray"), + objc_flags); + + AddOneLineSummary (objc_category_sp, + ConstString("NSPoint"), + objc_flags); + AddOneLineSummary (objc_category_sp, + ConstString("NSSize"), + objc_flags); + AddOneLineSummary (objc_category_sp, + ConstString("NSRect"), + objc_flags); + + AddOneLineSummary (objc_category_sp, + ConstString("CGSize"), + objc_flags); + AddOneLineSummary (objc_category_sp, + ConstString("CGPoint"), + objc_flags); + AddOneLineSummary (objc_category_sp, + ConstString("CGRect"), + objc_flags); + + AddStringSummary(objc_category_sp, + "red=${var.red} green=${var.green} blue=${var.blue}", + ConstString("RGBColor"), + objc_flags); + AddStringSummary(objc_category_sp, + "(t=${var.top}, l=${var.left}, b=${var.bottom}, r=${var.right})", + ConstString("Rect"), + objc_flags); + AddStringSummary(objc_category_sp, + "{(v=${var.v}, h=${var.h})}", + ConstString("Point"), + objc_flags); + AddStringSummary(objc_category_sp, + "${var.month}/${var.day}/${var.year} ${var.hour} :${var.minute} :${var.second} dayOfWeek:${var.dayOfWeek}", + ConstString("DateTimeRect *"), + objc_flags); + AddStringSummary(objc_category_sp, + "${var.ld.month}/${var.ld.day}/${var.ld.year} ${var.ld.hour} :${var.ld.minute} :${var.ld.second} dayOfWeek:${var.ld.dayOfWeek}", + ConstString("LongDateRect"), + objc_flags); + AddStringSummary(objc_category_sp, + "(x=${var.x}, y=${var.y})", + ConstString("HIPoint"), + objc_flags); + AddStringSummary(objc_category_sp, + "origin=${var.origin} size=${var.size}", + ConstString("HIRect"), + objc_flags); + + TypeSummaryImpl::Flags appkit_flags; + appkit_flags.SetCascades(true) + .SetSkipPointers(false) + .SetSkipReferences(false) + .SetDontShowChildren(true) + .SetDontShowValue(false) + .SetShowMembersOneLiner(false) + .SetHideItemNames(false); + + appkit_flags.SetDontShowChildren(false); + +#ifndef LLDB_DISABLE_PYTHON + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSArray"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArray0"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFMutableArrayRef"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSDictionary"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSMutableDictionary"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSCFDictionary"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryI"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryM"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFDictionaryRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFMutableDictionaryRef"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSSet summary", ConstString("NSSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>, "CFSetRef summary", ConstString("CFSetRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>, "CFMutableSetRef summary", ConstString("CFMutableSetRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSCFSet summary", ConstString("__NSCFSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSSetI summary", ConstString("__NSSetI"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSSetM summary", ConstString("__NSSetM"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSCountedSet summary", ConstString("NSCountedSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSOrderedSet summary", ConstString("NSOrderedSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSOrderedSetI summary", ConstString("__NSOrderedSetI"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSOrderedSetM summary", ConstString("__NSOrderedSetM"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSError_SummaryProvider, "NSError summary provider", ConstString("NSError"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSException_SummaryProvider, "NSException summary provider", ConstString("NSException"), appkit_flags); + + // AddSummary(appkit_category_sp, "${var.key%@} -> ${var.value%@}", ConstString("$_lldb_typegen_nspair"), appkit_flags); + + appkit_flags.SetDontShowChildren(true); + + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayM"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayI"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArray0"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSArray"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSMutableArray"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSCFArray"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("CFMutableArrayRef"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("CFArrayRef"), ScriptedSyntheticChildren::Flags()); + + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryM"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryI"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSCFDictionary"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSDictionary"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSMutableDictionary"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFDictionaryRef"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFMutableDictionaryRef"), ScriptedSyntheticChildren::Flags()); + + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSErrorSyntheticFrontEndCreator, "NSError synthetic children", ConstString("NSError"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSExceptionSyntheticFrontEndCreator, "NSException synthetic children", ConstString("NSException"), ScriptedSyntheticChildren::Flags()); + + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSSet synthetic children", ConstString("NSSet"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSSetI synthetic children", ConstString("__NSSetI"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSSetM synthetic children", ConstString("__NSSetM"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSMutableSet synthetic children", ConstString("NSMutableSet"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSOrderedSet synthetic children", ConstString("NSOrderedSet"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSOrderedSetI synthetic children", ConstString("__NSOrderedSetI"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSOrderedSetM synthetic children", ConstString("__NSOrderedSetM"), ScriptedSyntheticChildren::Flags()); + + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSIndexPathSyntheticFrontEndCreator, "NSIndexPath synthetic children", ConstString("NSIndexPath"), ScriptedSyntheticChildren::Flags()); + + AddCXXSummary(objc_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("CFBagRef"), appkit_flags); + AddCXXSummary(objc_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("__CFBag"), appkit_flags); + AddCXXSummary(objc_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("const struct __CFBag"), appkit_flags); + AddCXXSummary(objc_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("CFMutableBagRef"), appkit_flags); + + AddCXXSummary(objc_category_sp,lldb_private::formatters::CFBinaryHeapSummaryProvider, "CFBinaryHeap summary provider", ConstString("CFBinaryHeapRef"), appkit_flags); + AddCXXSummary(objc_category_sp,lldb_private::formatters::CFBinaryHeapSummaryProvider, "CFBinaryHeap summary provider", ConstString("__CFBinaryHeap"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFStringRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__CFString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFMutableStringRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSMutableString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFConstantString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFConstantString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSPathStore2"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSAttributedStringSummaryProvider, "NSAttributedString summary provider", ConstString("NSAttributedString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSMutableAttributedString"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSConcreteMutableAttributedString"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSBundleSummaryProvider, "NSBundle summary provider", ConstString("NSBundle"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSData"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteData"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteMutableData"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSMutableData"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("__NSCFData"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFDataRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFMutableDataRef"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSMachPortSummaryProvider, "NSMachPort summary provider", ConstString("NSMachPort"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSNotification"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSConcreteNotification"), appkit_flags); + + AddStringSummary(objc_category_sp, "domain: ${var._domain} - code: ${var._code}", ConstString("NSError"), appkit_flags); + AddStringSummary(objc_category_sp,"name:${var.name%S} reason:${var.reason%S}",ConstString("NSException"),appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSNumber"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "CFNumberRef summary provider", ConstString("CFNumberRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFNumber"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFBoolean"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFNumber"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSDecimalNumber summary provider", ConstString("NSDecimalNumber"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSHost summary provider", ConstString("NSHost"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSTask summary provider", ConstString("NSTask"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSValue summary provider", ConstString("NSValue"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("NSURL"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("CFURLRef"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("NSDate"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("__NSDate"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("__NSTaggedDate"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("NSCalendarDate"), appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("NSTimeZone"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("CFTimeZoneRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("__NSTimeZone"), appkit_flags); + + // CFAbsoluteTime is actually a double rather than a pointer to an object + // we do not care about the numeric value, since it is probably meaningless to users + appkit_flags.SetDontShowValue(true); + AddCXXSummary(objc_category_sp, lldb_private::formatters::CFAbsoluteTimeSummaryProvider, "CFAbsoluteTime summary provider", ConstString("CFAbsoluteTime"), appkit_flags); + appkit_flags.SetDontShowValue(false); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider, "NSIndexSet summary provider", ConstString("NSIndexSet"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider, "NSIndexSet summary provider", ConstString("NSMutableIndexSet"), appkit_flags); + + AddStringSummary(objc_category_sp, + "@\"${var.month%d}/${var.day%d}/${var.year%d} ${var.hour%d}:${var.minute%d}:${var.second}\"", + ConstString("CFGregorianDate"), + appkit_flags); + + AddCXXSummary(objc_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("CFBitVectorRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("CFMutableBitVectorRef"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("__CFBitVector"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("__CFMutableBitVector"), appkit_flags); +#endif // LLDB_DISABLE_PYTHON +} + +static void +LoadCoreMediaFormatters(TypeCategoryImplSP objc_category_sp) +{ + if (!objc_category_sp) + return; + + TypeSummaryImpl::Flags cm_flags; + cm_flags.SetCascades(true) + .SetDontShowChildren(false) + .SetDontShowValue(false) + .SetHideItemNames(false) + .SetShowMembersOneLiner(false) + .SetSkipPointers(false) + .SetSkipReferences(false); + +#ifndef LLDB_DISABLE_PYTHON + AddCXXSummary(objc_category_sp, lldb_private::formatters::CMTimeSummaryProvider, "CMTime summary provider", ConstString("CMTime"), cm_flags); +#endif // LLDB_DISABLE_PYTHON +} + +lldb::TypeCategoryImplSP +ObjCLanguage::GetFormatters () +{ + static std::once_flag g_initialize; + static TypeCategoryImplSP g_category; + + std::call_once(g_initialize, [this] () -> void { + DataVisualization::Categories::GetCategory(GetPluginName(), g_category); + if (g_category) + { + LoadCoreMediaFormatters(g_category); + LoadObjCFormatters(g_category); + } + }); + return g_category; +} + +std::vector<ConstString> +ObjCLanguage::GetPossibleFormattersMatches (ValueObject& valobj, lldb::DynamicValueType use_dynamic) +{ + std::vector<ConstString> result; + + if (use_dynamic == lldb::eNoDynamicValues) + return result; + + CompilerType compiler_type(valobj.GetCompilerType()); + + const bool check_cpp = false; + const bool check_objc = true; + bool canBeObjCDynamic = compiler_type.IsPossibleDynamicType(nullptr, check_cpp, check_objc); + + if (canBeObjCDynamic) + { + do { + lldb::ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + break; + ObjCLanguageRuntime* runtime = process_sp->GetObjCLanguageRuntime(); + if (runtime == nullptr) + break; + ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp (runtime->GetClassDescriptor(valobj)); + if (!objc_class_sp) + break; + if (ConstString name = objc_class_sp->GetClassName()) + result.push_back(name); + } while (false); + } + + return result; +} + +std::unique_ptr<Language::TypeScavenger> +ObjCLanguage::GetTypeScavenger () +{ + class ObjCTypeScavenger : public Language::TypeScavenger + { + private: + class ObjCScavengerResult : public Language::TypeScavenger::Result + { + public: + ObjCScavengerResult (CompilerType type) : + Language::TypeScavenger::Result(), + m_compiler_type(type) + { + } + + bool + IsValid () override + { + return m_compiler_type.IsValid(); + } + + bool + DumpToStream (Stream& stream, + bool print_help_if_available) override + { + if (IsValid()) + { + m_compiler_type.DumpTypeDescription(&stream); + stream.EOL(); + return true; + } + return false; + } + + ~ObjCScavengerResult() override = default; + + private: + CompilerType m_compiler_type; + }; + + protected: + ObjCTypeScavenger() = default; + + ~ObjCTypeScavenger() override = default; + + bool + Find_Impl (ExecutionContextScope *exe_scope, + const char *key, + ResultSet &results) override + { + bool result = false; + + Target* target = exe_scope->CalculateTarget().get(); + if (target) + { + if (auto clang_modules_decl_vendor = target->GetClangModulesDeclVendor()) + { + std::vector <clang::NamedDecl*> decls; + ConstString key_cs(key); + + if (clang_modules_decl_vendor->FindDecls(key_cs, false, UINT32_MAX, decls) > 0 && + decls.size() > 0) + { + CompilerType module_type = ClangASTContext::GetTypeForDecl(decls.front()); + result = true; + std::unique_ptr<Language::TypeScavenger::Result> result(new ObjCScavengerResult(module_type)); + results.insert(std::move(result)); + } + } + } + + if (!result) + { + Process* process = exe_scope->CalculateProcess().get(); + if (process) + { + const bool create_on_demand = false; + auto objc_runtime = process->GetObjCLanguageRuntime(create_on_demand); + if (objc_runtime) + { + auto decl_vendor = objc_runtime->GetDeclVendor(); + if (decl_vendor) + { + std::vector<clang::NamedDecl *> decls; + ConstString name(key); + decl_vendor->FindDecls(name, true, UINT32_MAX, decls); + for (auto decl : decls) + { + if (decl) + { + if (CompilerType candidate = ClangASTContext::GetTypeForDecl(decl)) + { + result = true; + std::unique_ptr<Language::TypeScavenger::Result> result(new ObjCScavengerResult(candidate)); + results.insert(std::move(result)); + } + } + } + } + } + } + } + + return result; + } + + friend class lldb_private::ObjCLanguage; + }; + + return std::unique_ptr<TypeScavenger>(new ObjCTypeScavenger()); +} + +bool +ObjCLanguage::GetFormatterPrefixSuffix (ValueObject& valobj, ConstString type_hint, + std::string& prefix, std::string& suffix) +{ + static ConstString g_CFBag("CFBag"); + static ConstString g_CFBinaryHeap("CFBinaryHeap"); + + static ConstString g_NSNumberChar("NSNumber:char"); + static ConstString g_NSNumberShort("NSNumber:short"); + static ConstString g_NSNumberInt("NSNumber:int"); + static ConstString g_NSNumberLong("NSNumber:long"); + static ConstString g_NSNumberFloat("NSNumber:float"); + static ConstString g_NSNumberDouble("NSNumber:double"); + + static ConstString g_NSData("NSData"); + static ConstString g_NSArray("NSArray"); + static ConstString g_NSString("NSString"); + static ConstString g_NSStringStar("NSString*"); + + if (type_hint.IsEmpty()) + return false; + + prefix.clear(); + suffix.clear(); + + if (type_hint == g_CFBag || + type_hint == g_CFBinaryHeap) + { + prefix = "@"; + return true; + } + + if (type_hint == g_NSNumberChar) + { + prefix = "(char)"; + return true; + } + if (type_hint == g_NSNumberShort) + { + prefix = "(short)"; + return true; + } + if (type_hint == g_NSNumberInt) + { + prefix = "(int)"; + return true; + } + if (type_hint == g_NSNumberLong) + { + prefix = "(long)"; + return true; + } + if (type_hint == g_NSNumberFloat) + { + prefix = "(float)"; + return true; + } + if (type_hint == g_NSNumberDouble) + { + prefix = "(double)"; + return true; + } + + if (type_hint == g_NSData || + type_hint == g_NSArray) + { + prefix = "@\""; + suffix = "\""; + return true; + } + + if (type_hint == g_NSString || + type_hint == g_NSStringStar) + { + prefix = "@"; + return true; + } + + return false; +} + +bool +ObjCLanguage::IsNilReference (ValueObject& valobj) +{ + const uint32_t mask = eTypeIsObjC | eTypeIsPointer; + bool isObjCpointer = (((valobj.GetCompilerType().GetTypeInfo(nullptr)) & mask) == mask); + if (!isObjCpointer) + return false; + bool canReadValue = true; + bool isZero = valobj.GetValueAsUnsigned(0,&canReadValue) == 0; + return canReadValue && isZero; +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.h new file mode 100644 index 000000000000..e30aa18c0443 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.h @@ -0,0 +1,210 @@ +//===-- ObjCLanguage.h ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_ObjCLanguage_h_ +#define liblldb_ObjCLanguage_h_ + +// C Includes +// C++ Includes +#include <vector> + +// Other libraries and framework includes +// Project includes +#include "lldb/lldb-private.h" +#include "lldb/Core/ConstString.h" +#include "lldb/Target/Language.h" + +namespace lldb_private { + +class ObjCLanguage : + public Language +{ +public: + class MethodName + { + public: + enum Type + { + eTypeUnspecified, + eTypeClassMethod, + eTypeInstanceMethod + }; + + MethodName () : + m_full(), + m_class(), + m_category(), + m_selector(), + m_type (eTypeUnspecified), + m_category_is_valid (false) + { + } + + MethodName (const char *name, bool strict) : + m_full(), + m_class(), + m_category(), + m_selector(), + m_type (eTypeUnspecified), + m_category_is_valid (false) + { + SetName (name, strict); + } + + void + Clear(); + + bool + IsValid (bool strict) const + { + // If "strict" is true, the name must have everything specified including + // the leading "+" or "-" on the method name + if (strict && m_type == eTypeUnspecified) + return false; + // Other than that, m_full will only be filled in if the objective C + // name is valid. + return (bool)m_full; + } + + bool + HasCategory() + { + return !GetCategory().IsEmpty(); + } + + Type + GetType () const + { + return m_type; + } + + const ConstString & + GetFullName () const + { + return m_full; + } + + ConstString + GetFullNameWithoutCategory (bool empty_if_no_category); + + bool + SetName (const char *name, bool strict); + + const ConstString & + GetClassName (); + + const ConstString & + GetClassNameWithCategory (); + + const ConstString & + GetCategory (); + + const ConstString & + GetSelector (); + + // Get all possible names for a method. Examples: + // If name is "+[NSString(my_additions) myStringWithCString:]" + // names[0] => "+[NSString(my_additions) myStringWithCString:]" + // names[1] => "+[NSString myStringWithCString:]" + // If name is specified without the leading '+' or '-' like "[NSString(my_additions) myStringWithCString:]" + // names[0] => "+[NSString(my_additions) myStringWithCString:]" + // names[1] => "-[NSString(my_additions) myStringWithCString:]" + // names[2] => "+[NSString myStringWithCString:]" + // names[3] => "-[NSString myStringWithCString:]" + size_t + GetFullNames (std::vector<ConstString> &names, bool append); + + protected: + ConstString m_full; // Full name: "+[NSString(my_additions) myStringWithCString:]" + ConstString m_class; // Class name: "NSString" + ConstString m_class_category; // Class with category: "NSString(my_additions)" + ConstString m_category; // Category: "my_additions" + ConstString m_selector; // Selector: "myStringWithCString:" + Type m_type; + bool m_category_is_valid; + }; + + ObjCLanguage() = default; + + ~ObjCLanguage() override = default; + + lldb::LanguageType + GetLanguageType () const override + { + return lldb::eLanguageTypeObjC; + } + + lldb::TypeCategoryImplSP + GetFormatters () override; + + std::vector<ConstString> + GetPossibleFormattersMatches (ValueObject& valobj, lldb::DynamicValueType use_dynamic) override; + + std::unique_ptr<TypeScavenger> + GetTypeScavenger () override; + + bool + GetFormatterPrefixSuffix (ValueObject& valobj, ConstString type_hint, + std::string& prefix, std::string& suffix) override; + + bool + IsNilReference (ValueObject& valobj) override; + + //------------------------------------------------------------------ + // Static Functions + //------------------------------------------------------------------ + static void + Initialize(); + + static void + Terminate(); + + static lldb_private::Language * + CreateInstance (lldb::LanguageType language); + + static lldb_private::ConstString + GetPluginNameStatic(); + + static bool + IsPossibleObjCMethodName (const char *name) + { + if (!name) + return false; + bool starts_right = (name[0] == '+' || name[0] == '-') && name[1] == '['; + bool ends_right = (name[strlen(name) - 1] == ']'); + return (starts_right && ends_right); + } + + static bool + IsPossibleObjCSelector (const char *name) + { + if (!name) + return false; + + if (strchr(name, ':') == NULL) + return true; + else if (name[strlen(name) - 1] == ':') + return true; + else + return false; + } + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + ConstString + GetPluginName() override; + + uint32_t + GetPluginVersion() override; +}; + +} // namespace lldb_private + +#endif // liblldb_ObjCLanguage_h_ diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.cpp b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.cpp new file mode 100644 index 000000000000..62ddafefad97 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.cpp @@ -0,0 +1,68 @@ +//===-- ObjCPlusPlusLanguage.cpp --------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ObjCPlusPlusLanguage.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/PluginManager.h" + +using namespace lldb; +using namespace lldb_private; + +void +ObjCPlusPlusLanguage::Initialize() +{ + PluginManager::RegisterPlugin (GetPluginNameStatic(), + "Objective-C++ Language", + CreateInstance); +} + +void +ObjCPlusPlusLanguage::Terminate() +{ + PluginManager::UnregisterPlugin (CreateInstance); +} + +lldb_private::ConstString +ObjCPlusPlusLanguage::GetPluginNameStatic() +{ + static ConstString g_name("objcplusplus"); + return g_name; +} + + +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +lldb_private::ConstString +ObjCPlusPlusLanguage::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +ObjCPlusPlusLanguage::GetPluginVersion() +{ + return 1; +} + +//------------------------------------------------------------------ +// Static Functions +//------------------------------------------------------------------ +Language * +ObjCPlusPlusLanguage::CreateInstance (lldb::LanguageType language) +{ + switch (language) + { + case lldb::eLanguageTypeObjC_plus_plus: + return new ObjCPlusPlusLanguage(); + default: + return nullptr; + } +} diff --git a/contrib/llvm/tools/lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h new file mode 100644 index 000000000000..0e1db66b0899 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h @@ -0,0 +1,63 @@ +//===-- ObjCPlusPlusLanguage.h ----------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_ObjCPlusPlusLanguage_h_ +#define liblldb_ObjCPlusPlusLanguage_h_ + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "lldb/lldb-private.h" +#include "lldb/Target/Language.h" + +namespace lldb_private { + +class ObjCPlusPlusLanguage : + public Language +{ +public: + ObjCPlusPlusLanguage() = default; + + ~ObjCPlusPlusLanguage() override = default; + + lldb::LanguageType + GetLanguageType() const override + { + return lldb::eLanguageTypeObjC_plus_plus; + } + + //------------------------------------------------------------------ + // Static Functions + //------------------------------------------------------------------ + static void + Initialize(); + + static void + Terminate(); + + static lldb_private::Language * + CreateInstance (lldb::LanguageType language); + + static lldb_private::ConstString + GetPluginNameStatic(); + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + ConstString + GetPluginName() override; + + uint32_t + GetPluginVersion() override; +}; + +} // namespace lldb_private + +#endif // liblldb_CPlusPlusLanguage_h_ |