diff options
Diffstat (limited to 'source/Plugins/Language/CPlusPlus')
20 files changed, 3940 insertions, 3404 deletions
diff --git a/source/Plugins/Language/CPlusPlus/BlockPointer.cpp b/source/Plugins/Language/CPlusPlus/BlockPointer.cpp index 92e30d54f6e1..db7c24675825 100644 --- a/source/Plugins/Language/CPlusPlus/BlockPointer.cpp +++ b/source/Plugins/Language/CPlusPlus/BlockPointer.cpp @@ -27,199 +27,185 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; -namespace lldb_private -{ -namespace formatters -{ +namespace lldb_private { +namespace formatters { -class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd -{ +class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd { public: - BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) - : SyntheticChildrenFrontEnd(*valobj_sp), - m_block_struct_type() - { - CompilerType block_pointer_type(m_backend.GetCompilerType()); - CompilerType function_pointer_type; - block_pointer_type.IsBlockPointerType(&function_pointer_type); - - TargetSP target_sp(m_backend.GetTargetSP()); - - if (!target_sp) - { - return; - } - - Error err; - TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(&err, lldb::eLanguageTypeC_plus_plus); - - if (!err.Success() || !type_system) - { - return; - } - - ClangASTContext *clang_ast_context = llvm::dyn_cast<ClangASTContext>(type_system); - - if (!clang_ast_context) - { - return; - } - - ClangASTImporterSP clang_ast_importer = target_sp->GetClangASTImporter(); - - if (!clang_ast_importer) - { - return; - } - - const char *const isa_name("__isa"); - const CompilerType isa_type = clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass); - const char *const flags_name("__flags"); - const CompilerType flags_type = clang_ast_context->GetBasicType(lldb::eBasicTypeInt); - const char *const reserved_name("__reserved"); - const CompilerType reserved_type = clang_ast_context->GetBasicType(lldb::eBasicTypeInt); - const char *const FuncPtr_name("__FuncPtr"); - const CompilerType FuncPtr_type = clang_ast_importer->CopyType(*clang_ast_context, function_pointer_type); - - m_block_struct_type = clang_ast_context->CreateStructForIdentifier(ConstString(), - { - {isa_name, isa_type}, - {flags_name, flags_type}, - {reserved_name, reserved_type}, - {FuncPtr_name, FuncPtr_type} - }); + BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_block_struct_type() { + CompilerType block_pointer_type(m_backend.GetCompilerType()); + CompilerType function_pointer_type; + block_pointer_type.IsBlockPointerType(&function_pointer_type); + TargetSP target_sp(m_backend.GetTargetSP()); + + if (!target_sp) { + return; + } + + Error err; + TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage( + &err, lldb::eLanguageTypeC_plus_plus); + + if (!err.Success() || !type_system) { + return; + } + + ClangASTContext *clang_ast_context = + llvm::dyn_cast<ClangASTContext>(type_system); + + if (!clang_ast_context) { + return; } - ~BlockPointerSyntheticFrontEnd() override = default; + ClangASTImporterSP clang_ast_importer = target_sp->GetClangASTImporter(); - size_t - CalculateNumChildren() override - { - const bool omit_empty_base_classes = false; - return m_block_struct_type.GetNumChildren(omit_empty_base_classes); + if (!clang_ast_importer) { + return; } - lldb::ValueObjectSP - GetChildAtIndex(size_t idx) override - { - if (!m_block_struct_type.IsValid()) - { - return lldb::ValueObjectSP(); - } - - if (idx >= CalculateNumChildren()) - { - return lldb::ValueObjectSP(); - } - - const bool thread_and_frame_only_if_stopped = true; - ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock(thread_and_frame_only_if_stopped); - const bool transparent_pointers = false; - const bool omit_empty_base_classes = false; - const bool ignore_array_bounds = false; - ValueObject *value_object = nullptr; - - std::string child_name; - uint32_t child_byte_size = 0; - int32_t child_byte_offset = 0; - uint32_t child_bitfield_bit_size = 0; - uint32_t child_bitfield_bit_offset = 0; - bool child_is_base_class = false; - bool child_is_deref_of_parent = false; - uint64_t language_flags = 0; - - const CompilerType child_type = m_block_struct_type.GetChildCompilerTypeAtIndex(&exe_ctx, idx, transparent_pointers, omit_empty_base_classes, ignore_array_bounds, child_name, child_byte_size, child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class, child_is_deref_of_parent, value_object, language_flags); - - ValueObjectSP struct_pointer_sp = m_backend.Cast(m_block_struct_type.GetPointerType()); - - if (!struct_pointer_sp) - { - return lldb::ValueObjectSP(); - } - - Error err; - ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err); - - if (!struct_sp || !err.Success()) - { - return lldb::ValueObjectSP(); - } - - ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset(child_byte_offset, - child_type, - true, - ConstString(child_name.c_str(), child_name.size()))); - - return child_sp; + const char *const isa_name("__isa"); + const CompilerType isa_type = + clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass); + const char *const flags_name("__flags"); + const CompilerType flags_type = + clang_ast_context->GetBasicType(lldb::eBasicTypeInt); + const char *const reserved_name("__reserved"); + const CompilerType reserved_type = + clang_ast_context->GetBasicType(lldb::eBasicTypeInt); + const char *const FuncPtr_name("__FuncPtr"); + const CompilerType FuncPtr_type = + clang_ast_importer->CopyType(*clang_ast_context, function_pointer_type); + + m_block_struct_type = clang_ast_context->CreateStructForIdentifier( + ConstString(), {{isa_name, isa_type}, + {flags_name, flags_type}, + {reserved_name, reserved_type}, + {FuncPtr_name, FuncPtr_type}}); + } + + ~BlockPointerSyntheticFrontEnd() override = default; + + size_t CalculateNumChildren() override { + const bool omit_empty_base_classes = false; + return m_block_struct_type.GetNumChildren(omit_empty_base_classes); + } + + lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { + if (!m_block_struct_type.IsValid()) { + return lldb::ValueObjectSP(); } - // return true if this object is now safe to use forever without - // ever updating again; the typical (and tested) answer here is - // 'false' - bool - Update() override - { - return false; + if (idx >= CalculateNumChildren()) { + return lldb::ValueObjectSP(); } - // maybe return false if the block pointer is, say, null - bool - MightHaveChildren() override - { - return true; + const bool thread_and_frame_only_if_stopped = true; + ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock( + thread_and_frame_only_if_stopped); + const bool transparent_pointers = false; + const bool omit_empty_base_classes = false; + const bool ignore_array_bounds = false; + ValueObject *value_object = nullptr; + + std::string child_name; + uint32_t child_byte_size = 0; + int32_t child_byte_offset = 0; + uint32_t child_bitfield_bit_size = 0; + uint32_t child_bitfield_bit_offset = 0; + bool child_is_base_class = false; + bool child_is_deref_of_parent = false; + uint64_t language_flags = 0; + + const CompilerType child_type = + m_block_struct_type.GetChildCompilerTypeAtIndex( + &exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, + child_is_base_class, child_is_deref_of_parent, value_object, + language_flags); + + ValueObjectSP struct_pointer_sp = + m_backend.Cast(m_block_struct_type.GetPointerType()); + + if (!struct_pointer_sp) { + return lldb::ValueObjectSP(); } - size_t - GetIndexOfChildWithName(const ConstString &name) override - { - if (!m_block_struct_type.IsValid()) - return UINT32_MAX; - - const bool omit_empty_base_classes = false; - return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(), omit_empty_base_classes); + Error err; + ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err); + + if (!struct_sp || !err.Success()) { + return lldb::ValueObjectSP(); } + ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset( + child_byte_offset, child_type, true, + ConstString(child_name.c_str(), child_name.size()))); + + return child_sp; + } + + // return true if this object is now safe to use forever without + // ever updating again; the typical (and tested) answer here is + // 'false' + bool Update() override { return false; } + + // maybe return false if the block pointer is, say, null + bool MightHaveChildren() override { return true; } + + size_t GetIndexOfChildWithName(const ConstString &name) override { + if (!m_block_struct_type.IsValid()) + return UINT32_MAX; + + const bool omit_empty_base_classes = false; + return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(), + omit_empty_base_classes); + } + private: - CompilerType m_block_struct_type; + CompilerType m_block_struct_type; }; } // namespace formatters } // namespace lldb_private -bool -lldb_private::formatters::BlockPointerSummaryProvider(ValueObject &valobj, Stream &s, const TypeSummaryOptions &) -{ - lldb_private::SyntheticChildrenFrontEnd *synthetic_children = BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP()); - if (!synthetic_children) - { - return false; - } +bool lldb_private::formatters::BlockPointerSummaryProvider( + ValueObject &valobj, Stream &s, const TypeSummaryOptions &) { + lldb_private::SyntheticChildrenFrontEnd *synthetic_children = + BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP()); + if (!synthetic_children) { + return false; + } - synthetic_children->Update(); + synthetic_children->Update(); - static const ConstString s_FuncPtr_name("__FuncPtr"); - - lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex(synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name)); - - if (!child_sp) - { - return false; - } - - lldb::ValueObjectSP qualified_child_representation_sp = child_sp->GetQualifiedRepresentationIfAvailable(lldb::eDynamicDontRunTarget, true); + static const ConstString s_FuncPtr_name("__FuncPtr"); + + lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex( + synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name)); + + if (!child_sp) { + return false; + } + + lldb::ValueObjectSP qualified_child_representation_sp = + child_sp->GetQualifiedRepresentationIfAvailable( + lldb::eDynamicDontRunTarget, true); - const char *child_value = qualified_child_representation_sp->GetValueAsCString(); + const char *child_value = + qualified_child_representation_sp->GetValueAsCString(); - s.Printf("%s", child_value); + s.Printf("%s", child_value); - return true; + return true; } lldb_private::SyntheticChildrenFrontEnd * -lldb_private::formatters::BlockPointerSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) -{ - if (!valobj_sp) - return nullptr; - return new BlockPointerSyntheticFrontEnd(valobj_sp); +lldb_private::formatters::BlockPointerSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + if (!valobj_sp) + return nullptr; + return new BlockPointerSyntheticFrontEnd(valobj_sp); } diff --git a/source/Plugins/Language/CPlusPlus/BlockPointer.h b/source/Plugins/Language/CPlusPlus/BlockPointer.h index 5e6c748b5dbb..e5008a8f3676 100644 --- a/source/Plugins/Language/CPlusPlus/BlockPointer.h +++ b/source/Plugins/Language/CPlusPlus/BlockPointer.h @@ -12,15 +12,14 @@ #include "lldb/lldb-forward.h" -namespace lldb_private -{ -namespace formatters -{ -bool -BlockPointerSummaryProvider(ValueObject &, Stream &, const TypeSummaryOptions &); +namespace lldb_private { +namespace formatters { +bool BlockPointerSummaryProvider(ValueObject &, Stream &, + const TypeSummaryOptions &); SyntheticChildrenFrontEnd * -BlockPointerSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP); +BlockPointerSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); } // namespace formatters } // namespace lldb_private diff --git a/source/Plugins/Language/CPlusPlus/CMakeLists.txt b/source/Plugins/Language/CPlusPlus/CMakeLists.txt index de0dc99d85dd..5e105aa19b6b 100644 --- a/source/Plugins/Language/CPlusPlus/CMakeLists.txt +++ b/source/Plugins/Language/CPlusPlus/CMakeLists.txt @@ -10,4 +10,6 @@ add_lldb_library(lldbPluginCPlusPlusLanguage LibCxxUnorderedMap.cpp LibCxxVector.cpp LibStdcpp.cpp + LibStdcppTuple.cpp + LibStdcppUniquePointer.cpp ) diff --git a/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp index 33d22bf2e583..b5527edacd13 100644 --- a/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp +++ b/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp @@ -10,17 +10,22 @@ #include "CPlusPlusLanguage.h" // C Includes -// C++ Includes -#include <cstring> #include <cctype> +#include <cstring> + +// C++ Includes #include <functional> +#include <memory> #include <mutex> +#include <set> // Other libraries and framework includes #include "llvm/ADT/StringRef.h" // Project includes #include "lldb/Core/ConstString.h" +#include "lldb/Core/FastDemangle.h" +#include "lldb/Core/Log.h" #include "lldb/Core/PluginManager.h" #include "lldb/Core/RegularExpression.h" #include "lldb/Core/UniqueCStringMap.h" @@ -39,818 +44,1122 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; -void -CPlusPlusLanguage::Initialize() -{ - PluginManager::RegisterPlugin (GetPluginNameStatic(), - "C++ Language", - CreateInstance); +void CPlusPlusLanguage::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language", + CreateInstance); } -void -CPlusPlusLanguage::Terminate() -{ - PluginManager::UnregisterPlugin (CreateInstance); +void CPlusPlusLanguage::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); } -lldb_private::ConstString -CPlusPlusLanguage::GetPluginNameStatic() -{ - static ConstString g_name("cplusplus"); - return g_name; +lldb_private::ConstString CPlusPlusLanguage::GetPluginNameStatic() { + static ConstString g_name("cplusplus"); + return g_name; } //------------------------------------------------------------------ // PluginInterface protocol //------------------------------------------------------------------ -lldb_private::ConstString -CPlusPlusLanguage::GetPluginName() -{ - return GetPluginNameStatic(); +lldb_private::ConstString CPlusPlusLanguage::GetPluginName() { + return GetPluginNameStatic(); } -uint32_t -CPlusPlusLanguage::GetPluginVersion() -{ - return 1; -} +uint32_t CPlusPlusLanguage::GetPluginVersion() { return 1; } //------------------------------------------------------------------ // Static Functions //------------------------------------------------------------------ -Language * -CPlusPlusLanguage::CreateInstance (lldb::LanguageType language) -{ - if (Language::LanguageIsCPlusPlus(language)) - return new CPlusPlusLanguage(); - return nullptr; +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; +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]; +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 || 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; - } + 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; + } + 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; +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 (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_] + 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] + // Read all characters matching [A-Za-z_0-9] + ++idx; + while (idx < basename.size()) { + if (!std::isalnum(basename[idx]) && basename[idx] != '_') + break; ++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; + // 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 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; + // 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); + static RegularExpression g_operator_regex( + llvm::StringRef("^(operator)( " + "?)([A-Za-z_][A-Za-z_0-9]*|\\(\\)|" + "\\[\\]|[\\^<>=!\\/" + "*+-]+)(<.*>)?(\\[\\])?$")); + std::string basename_str(basename.str()); + return g_operator_regex.Execute(basename_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; - } +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; 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; - } + ++context_start; + + 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); } - else - { - m_parse_error = true; + + 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 - context_start); + 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::GetBasename() { + if (!m_parsed) + Parse(); + return m_basename; } -llvm::StringRef -CPlusPlusLanguage::MethodName::GetContext () -{ - if (!m_parsed) - Parse(); - return m_context; +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::GetArguments() { + if (!m_parsed) + Parse(); + return m_arguments; } -llvm::StringRef -CPlusPlusLanguage::MethodName::GetQualifiers () -{ - if (!m_parsed) - Parse(); - return m_qualifiers; +llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() { + if (!m_parsed) + Parse(); + return m_qualifiers; } -std::string -CPlusPlusLanguage::MethodName::GetScopeQualifiedName () -{ - if (!m_parsed) - Parse(); - if (m_basename.empty() || m_context.empty()) - return std::string(); +std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() { + if (!m_parsed) + Parse(); + if (m_basename.empty() || m_context.empty()) + return std::string(); - std::string res; - res += m_context; - res += "::"; - res += m_basename; + std::string res; + res += m_context; + res += "::"; + res += m_basename; - return res; + return res; } -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. - - return (name != nullptr && name[0] == '_' && name[1] == 'Z'); +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. + + return (name != nullptr && name[0] == '_' && name[1] == 'Z'); } -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; +bool CPlusPlusLanguage::ExtractContextAndIdentifier( + const char *name, llvm::StringRef &context, llvm::StringRef &identifier) { + static RegularExpression g_basename_regex(llvm::StringRef( + "^(([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(llvm::StringRef::withNullAsEmpty(name), + &match)) { + match.GetMatchAtIndex(name, 1, context); + match.GetMatchAtIndex(name, 3, identifier); + return true; + } + return false; } -class CPPRuntimeEquivalents -{ +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 != nullptr; - match = m_impl.FindNextValueForName(match)) - { - equivalents.push_back(match->value); - count++; - } + CPPRuntimeEquivalents() { + m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, " + "std::allocator<char> >") + .GetStringRef(), + 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> >") + .GetStringRef(), + ConstString("std::basic_string<char>")); + + m_impl.Sort(); + } + + void Add(ConstString &type_name, ConstString &type_equivalent) { + m_impl.Insert(type_name.GetStringRef(), type_equivalent); + } - return count; + uint32_t FindExactMatches(ConstString &type_name, + std::vector<ConstString> &equivalents) { + uint32_t count = 0; + + for (ImplData match = + m_impl.FindFirstValueForName(type_name.GetStringRef()); + match != nullptr; match = m_impl.FindNextValueForName(match)) { + equivalents.push_back(match->value); + 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; + + 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; + + llvm::StringRef type_name_cstr = type_name.GetStringRef(); + + size_t items_count = m_impl.GetSize(); + + for (size_t item = 0; item < items_count; item++) { + llvm::StringRef key_cstr = m_impl.GetCStringAtIndex(item); + if (type_name_cstr.contains(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 != nullptr; - 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 + 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(llvm::StringRef original, + llvm::StringRef 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 != nullptr; 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); + Add(original_const, target_const); #endif - equivalents.push_back(target_const); - - count++; - } - - return count; + equivalents.push_back(target_const); + + count++; } - - typedef UniqueCStringMap<ConstString> Impl; - typedef const Impl::Entry* ImplData; - Impl m_impl; + + 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; +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(), '<') != nullptr // we should only have partial matches when templates are involved, check that we have - && strchr(type_name.AsCString(), '>') != nullptr); // 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; +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(), '<') != + nullptr // we should only have partial matches when templates are + // involved, check that we have + && strchr(type_name.AsCString(), '>') != nullptr); // 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); - +/// Given a mangled function `mangled`, replace all the primitive function type +/// arguments of `search` with type `replace`. +static ConstString SubsPrimitiveParmItanium(llvm::StringRef mangled, + llvm::StringRef search, + llvm::StringRef replace) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + const size_t max_len = + mangled.size() + mangled.count(search) * replace.size() + 1; + + // Make a temporary buffer to fix up the mangled parameter types and copy the + // original there + std::string output_buf; + output_buf.reserve(max_len); + output_buf.insert(0, mangled.str()); + ptrdiff_t replaced_offset = 0; + + auto swap_parms_hook = [&](const char *parsee) { + if (!parsee || !*parsee) + return; + + // Check whether we've found a substitutee + llvm::StringRef s(parsee); + if (s.startswith(search)) { + // account for the case where a replacement is of a different length to + // the original + replaced_offset += replace.size() - search.size(); + + ptrdiff_t replace_idx = (mangled.size() - s.size()) + replaced_offset; + output_buf.erase(replace_idx, search.size()); + output_buf.insert(replace_idx, replace.str()); + } + }; + + // FastDemangle will call our hook for each instance of a primitive type, + // allowing us to perform substitution + const char *const demangled = + FastDemangle(mangled.str().c_str(), mangled.size(), swap_parms_hook); + + if (log) + log->Printf("substituted mangling for %s:{%s} %s:{%s}\n", + mangled.str().c_str(), demangled, output_buf.c_str(), + FastDemangle(output_buf.c_str())); + + return output_buf == mangled ? ConstString() : ConstString(output_buf); +} + +uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( + const ConstString mangled_name, std::set<ConstString> &alternates) { + const auto start_size = alternates.size(); + /// Get a basic set of alternative manglings for the given symbol `name`, by + /// making a few basic possible substitutions on basic types, storage duration + /// and `const`ness for the given symbol. The output parameter `alternates` + /// is filled with a best-guess, non-exhaustive set of different manglings + /// for the given name. + + // Maybe we're looking for a const symbol but the debug info told us it was + // non-const... + if (!strncmp(mangled_name.GetCString(), "_ZN", 3) && + strncmp(mangled_name.GetCString(), "_ZNK", 4)) { + std::string fixed_scratch("_ZNK"); + fixed_scratch.append(mangled_name.GetCString() + 3); + alternates.insert(ConstString(fixed_scratch)); + } + + // Maybe we're looking for a static symbol but we thought it was global... + if (!strncmp(mangled_name.GetCString(), "_Z", 2) && + strncmp(mangled_name.GetCString(), "_ZL", 3)) { + std::string fixed_scratch("_ZL"); + fixed_scratch.append(mangled_name.GetCString() + 2); + alternates.insert(ConstString(fixed_scratch)); + } + + // `char` is implementation defined as either `signed` or `unsigned`. As a + // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed + // char, 'h'-unsigned char. If we're looking for symbols with a signed char + // parameter, try finding matches which have the general case 'c'. + if (ConstString char_fixup = + SubsPrimitiveParmItanium(mangled_name.GetStringRef(), "a", "c")) + alternates.insert(char_fixup); + + // long long parameter mangling 'x', may actually just be a long 'l' argument + if (ConstString long_fixup = + SubsPrimitiveParmItanium(mangled_name.GetStringRef(), "x", "l")) + alternates.insert(long_fixup); + + // unsigned long long parameter mangling 'y', may actually just be unsigned + // long 'm' argument + if (ConstString ulong_fixup = + SubsPrimitiveParmItanium(mangled_name.GetStringRef(), "y", "m")) + alternates.insert(ulong_fixup); + + return alternates.size() - start_size; +} + +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::__ndk1::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::__ndk1::basic_string<char, std::__ndk1::char_traits<char>, std::__ndk1::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::__ndk1::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); - cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__ndk1::basic_string<wchar_t, std::__ndk1::char_traits<wchar_t>, std::__ndk1::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::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("^std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__(ndk)?1::list<.+>(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__(ndk)?1::map<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__(ndk)?1::vector<std::__(ndk)?1::allocator<bool> >"), stl_synth_flags); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >"), stl_synth_flags); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__(ndk)?1::set<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__(ndk)?1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__(ndk)?1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__(ndk)?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); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator, "libc++ std::atomic synthetic children", ConstString("^std::__(ndk)?1::atomic<.+>$"), stl_synth_flags, true); - - cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__(ndk)?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::__(ndk)?1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__(ndk)?1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); - - stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(false); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__(ndk)?1::list<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__(ndk)?1::map<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__(ndk)?1::deque<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__(ndk)?1::set<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__(ndk)?1::multiset<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__(ndk)?1::multimap<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::unordered containers summary provider", ConstString("^(std::__(ndk)?1::)unordered_(multi)?(map|set)<.+> >$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider, "libc++ std::atomic summary provider", ConstString("^std::__(ndk)?1::atomic<.+>$"), 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::__(ndk)?1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::weak_ptr summary provider", ConstString("^std::__(ndk)?1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true); - - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__(ndk)?1::__wrap_iter<.+>$"), stl_synth_flags, true); - - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >"), stl_summary_flags); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__(ndk)?1::__map_iterator<.+>$"), stl_synth_flags, true); + 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::__ndk1::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::__ndk1::basic_string<char, " + "std::__ndk1::char_traits<char>, " + "std::__ndk1::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::__ndk1::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); + cpp_category_sp->GetTypeSummariesContainer()->Add( + ConstString("std::__ndk1::basic_string<wchar_t, " + "std::__ndk1::char_traits<wchar_t>, " + "std::__ndk1::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::LibcxxVectorBoolSyntheticFrontEndCreator, + "libc++ std::vector<bool> synthetic children", + ConstString( + "^std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >$"), + stl_synth_flags, true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, + "libc++ std::vector synthetic children", + ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), stl_synth_flags, + true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, + "libc++ std::list synthetic children", + ConstString("^std::__(ndk)?1::list<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, + "libc++ std::map synthetic children", + ConstString("^std::__(ndk)?1::map<.+> >(( )?&)?$"), stl_synth_flags, + true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, + "libc++ std::vector<bool> synthetic children", + ConstString("std::__(ndk)?1::vector<std::__(ndk)?1::allocator<bool> >"), + stl_synth_flags); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, + "libc++ std::vector<bool> synthetic children", + ConstString( + "std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >"), + stl_synth_flags); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, + "libc++ std::set synthetic children", + ConstString("^std::__(ndk)?1::set<.+> >(( )?&)?$"), stl_synth_flags, + true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, + "libc++ std::multiset synthetic children", + ConstString("^std::__(ndk)?1::multiset<.+> >(( )?&)?$"), stl_synth_flags, + true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, + "libc++ std::multimap synthetic children", + ConstString("^std::__(ndk)?1::multimap<.+> >(( )?&)?$"), stl_synth_flags, + true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, + "libc++ std::unordered containers synthetic children", + ConstString("^(std::__(ndk)?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); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator, + "libc++ std::atomic synthetic children", + ConstString("^std::__(ndk)?1::atomic<.+>$"), stl_synth_flags, true); + + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( + RegularExpressionSP(new RegularExpression( + llvm::StringRef("^(std::__(ndk)?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::__(ndk)?1::)shared_ptr<.+>(( )?&)?$"), + stl_synth_flags, true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, + "weak_ptr synthetic children", + ConstString("^(std::__(ndk)?1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, + true); + + stl_summary_flags.SetDontShowChildren(false); + stl_summary_flags.SetSkipPointers(false); + AddCXXSummary( + cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::vector<bool> summary provider", + ConstString( + "std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::vector summary provider", + ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::list summary provider", + ConstString("^std::__(ndk)?1::list<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::map summary provider", + ConstString("^std::__(ndk)?1::map<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::deque summary provider", + ConstString("^std::__(ndk)?1::deque<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::set summary provider", + ConstString("^std::__(ndk)?1::set<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::multiset summary provider", + ConstString("^std::__(ndk)?1::multiset<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::multimap summary provider", + ConstString("^std::__(ndk)?1::multimap<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary( + cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::unordered containers summary provider", + ConstString("^(std::__(ndk)?1::)unordered_(multi)?(map|set)<.+> >$"), + stl_summary_flags, true); + AddCXXSummary( + cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider, + "libc++ std::atomic summary provider", + ConstString("^std::__(ndk)?1::atomic<.+>$"), 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::__(ndk)?1::shared_ptr<.+>(( )?&)?$"), + stl_summary_flags, true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibcxxSmartPointerSummaryProvider, + "libc++ std::weak_ptr summary provider", + ConstString("^std::__(ndk)?1::weak_ptr<.+>(( )?&)?$"), + stl_summary_flags, true); + + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, + "std::vector iterator synthetic children", + ConstString("^std::__(ndk)?1::__wrap_iter<.+>$"), stl_synth_flags, true); + + AddCXXSummary( + cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, + "libc++ std::vector<bool> summary provider", + ConstString( + "std::__(ndk)?1::vector<bool, std::__(ndk)?1::allocator<bool> >"), + stl_summary_flags); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, + "std::map iterator synthetic children", + ConstString("^std::__(ndk)?1::__map_iterator<.+>$"), stl_synth_flags, + true); + + AddCXXSynthetic( + cpp_category_sp, lldb_private::formatters::LibcxxFunctionFrontEndCreator, + "std::function synthetic value provider", + ConstString("^std::__1::function<.+>$"), 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); +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); - - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, - "std::shared_ptr synthetic children", ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, - true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, - "std::weak_ptr synthetic children", ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, - true); - - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, - "libstdc++ std::shared_ptr summary provider", ConstString("^std::shared_ptr<.+>(( )?&)?$"), - stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, - "libstdc++ std::weak_ptr summary provider", ConstString("^std::weak_ptr<.+>(( )?&)?$"), - stl_summary_flags, true); + + SyntheticChildren::Flags stl_synth_flags; + stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( + false); + + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( + RegularExpressionSP( + new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))), + SyntheticChildrenSP(new ScriptedSyntheticChildren( + stl_synth_flags, + "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( + RegularExpressionSP( + new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))), + SyntheticChildrenSP(new ScriptedSyntheticChildren( + stl_synth_flags, + "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider"))); + cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( + RegularExpressionSP(new RegularExpression( + llvm::StringRef("^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(llvm::StringRef("^std::vector<.+>(( )?&)?$"))), + TypeSummaryImplSP( + new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); + cpp_category_sp->GetRegexTypeSummariesContainer()->Add( + RegularExpressionSP( + new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))), + TypeSummaryImplSP( + new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); + cpp_category_sp->GetRegexTypeSummariesContainer()->Add( + RegularExpressionSP(new RegularExpression( + llvm::StringRef("^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); + + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator, + "std::unique_ptr synthetic children", + ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, + "std::shared_ptr synthetic children", + ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, + "std::weak_ptr synthetic children", + ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); + AddCXXSynthetic( + cpp_category_sp, + lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator, + "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"), + stl_synth_flags, true); + + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibStdcppUniquePointerSummaryProvider, + "libstdc++ std::unique_ptr summary provider", + ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags, + true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, + "libstdc++ std::shared_ptr summary provider", + ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, + true); + AddCXXSummary(cpp_category_sp, + lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, + "libstdc++ std::weak_ptr summary provider", + ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_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); - +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); + // 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; +std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() { + class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger { + public: + virtual CompilerType AdjustForInclusion(CompilerType &candidate) override { + LanguageType lang_type(candidate.GetMinimumLanguage()); + if (!Language::LanguageIsC(lang_type) && + !Language::LanguageIsCPlusPlus(lang_type)) + return CompilerType(); + if (candidate.IsTypedefType()) + return candidate.GetTypedefedType(); + return candidate; + } + }; + + return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger()); +} + +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; - }); - 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::BlockPointerSummaryProvider, - "block pointer summary provider")); - if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) - { - return formatter_sp; - } - return nullptr; - }); - }); - - return g_formatters; +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; + }); + 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::BlockPointerSummaryProvider, + "block pointer summary provider")); + if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) { + 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; - }); - 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), - "block pointer synthetic children", - lldb_private::formatters::BlockPointerSyntheticFrontEndCreator)); - if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) - { - return formatter_sp; - } - return nullptr; - }); +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; + }); + 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), + "block pointer synthetic children", + lldb_private::formatters::BlockPointerSyntheticFrontEndCreator)); + if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) { + return formatter_sp; + } + return nullptr; }); - - return g_formatters; + + }); + + return g_formatters; } diff --git a/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h b/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h index f0fc07e20066..be5cbae57de2 100644 --- a/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h +++ b/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h @@ -12,178 +12,150 @@ // C Includes // C++ Includes +#include <set> #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" +#include "lldb/lldb-private.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; - } - - std::string - GetScopeQualifiedName (); - - 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; +class CPlusPlusLanguage : public Language { +public: + class MethodName { + public: + enum Type { + eTypeInvalid, + eTypeUnknownMethod, + eTypeClassMethod, + eTypeInstanceMethod }; - CPlusPlusLanguage() = default; + MethodName() + : m_full(), m_basename(), m_context(), m_arguments(), m_qualifiers(), + m_type(eTypeInvalid), m_parsed(false), m_parse_error(false) {} - ~CPlusPlusLanguage() override = default; + 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) {} - lldb::LanguageType - GetLanguageType () const override - { - return lldb::eLanguageTypeC_plus_plus; + void Clear(); + + bool IsValid() { + if (!m_parsed) + Parse(); + if (m_parse_error) + return false; + if (m_type == eTypeInvalid) + return false; + return (bool)m_full; } - - 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; + + Type GetType() const { return m_type; } + + const ConstString &GetFullName() const { return m_full; } + + std::string GetScopeQualifiedName(); + + 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; + } + + std::unique_ptr<TypeScavenger> GetTypeScavenger() override; + 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); + + // Given a mangled function name, calculates some alternative manglings since + // the compiler mangling may not line up with the symbol we are expecting + static uint32_t + FindAlternateFunctionManglings(const ConstString mangled, + std::set<ConstString> &candidates); + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; }; - + } // namespace lldb_private #endif // liblldb_CPlusPlusLanguage_h_ diff --git a/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp b/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp index a2c45fb99893..346ea0bbd519 100644 --- a/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp +++ b/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp @@ -1,4 +1,4 @@ -//===-- CXXStringTypes.cpp --------------------------------------*- C++ -*-===// +//===-- CxxStringTypes.cpp --------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -16,209 +16,208 @@ #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/Host/Time.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; - } - +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; - } - +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; - } +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::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::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; - - // 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::ReadBufferAndDumpToStreamOptions options(valobj); - options.SetData(data); - options.SetStream(&stream); - options.SetPrefixToken("L"); - options.SetQuote('\''); - options.SetSourceSize(1); - options.SetBinaryZeroIsTerminator(false); - - switch (wchar_size) - { - case 8: - return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF8>(options); - case 16: - return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); - case 32: - return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF32>(options); - default: - stream.Printf("size for wchar_t is not valid"); - return true; - } +bool lldb_private::formatters::WCharSummaryProvider( + ValueObject &valobj, Stream &stream, const TypeSummaryOptions &) { + DataExtractor data; + Error error; + valobj.GetData(data, error); + + if (error.Fail()) + 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::ReadBufferAndDumpToStreamOptions options(valobj); + options.SetData(data); + options.SetStream(&stream); + options.SetPrefixToken("L"); + options.SetQuote('\''); + options.SetSourceSize(1); + options.SetBinaryZeroIsTerminator(false); + + switch (wchar_size) { + case 8: + return StringPrinter::ReadBufferAndDumpToStream< + StringPrinter::StringElementType::UTF8>(options); + case 16: + return StringPrinter::ReadBufferAndDumpToStream< + StringPrinter::StringElementType::UTF16>(options); + case 32: + return StringPrinter::ReadBufferAndDumpToStream< + StringPrinter::StringElementType::UTF32>(options); + default: + stream.Printf("size for wchar_t is not valid"); return true; + } + return true; } diff --git a/source/Plugins/Language/CPlusPlus/CxxStringTypes.h b/source/Plugins/Language/CPlusPlus/CxxStringTypes.h index bfb03bda7ee0..0bee3bd3b0f2 100644 --- a/source/Plugins/Language/CPlusPlus/CxxStringTypes.h +++ b/source/Plugins/Language/CPlusPlus/CxxStringTypes.h @@ -1,4 +1,5 @@ -//===-- CxxStringTypes.h ----------------------------------------------*- C++ -*-===// +//===-- CxxStringTypes.h ----------------------------------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -15,27 +16,29 @@ #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 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/source/Plugins/Language/CPlusPlus/LibCxx.cpp b/source/Plugins/Language/CPlusPlus/LibCxx.cpp index beb89b89c635..82441a69b1d4 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxx.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxx.cpp @@ -27,202 +27,211 @@ #include "lldb/Host/Endian.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Target/Target.h" +#include "lldb/Utility/ProcessStructReader.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)); +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 (weakcount_sp) - stream.Printf(" weak=%" PRIu64, 1+weakcount_sp->GetValueAsUnsigned(0)); - + 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::PrintableRepresentationSpecialCases::eDisable, + 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), - 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); - } +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd:: + LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), 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; +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; +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.GetString(), 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> > = { + 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; - } +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; +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; +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() = default; +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd:: + ~LibcxxVectorBoolSyntheticFrontEnd() = default; -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp) + : nullptr); } /* (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 = { + (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 *> = { @@ -238,82 +247,144 @@ lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSynthetic second = { std::string } */ -lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_pair_ptr() -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: + LibCxxMapIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_pair_ptr(), m_pair_sp() { + 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; +bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() { + m_pair_sp.reset(); + m_pair_ptr = nullptr; - if (!valobj_sp) - return false; + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return false; + + TargetSP target_sp(valobj_sp->GetTargetSP()); - // 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_", - nullptr, - nullptr, - nullptr, - ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None), - nullptr).get(); - + if (!target_sp) return false; + + if (!valobj_sp) + return false; + + static ConstString g___i_("__i_"); + + // 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_", nullptr, nullptr, + ValueObject::GetValueForExpressionPathOptions() + .DontCheckDotVsArrowSyntax() + .SetSyntheticChildrenTraversal( + ValueObject::GetValueForExpressionPathOptions:: + SyntheticChildrenTraversal::None), + nullptr) + .get(); + + if (!m_pair_ptr) { + m_pair_ptr = valobj_sp + ->GetValueForExpressionPath( + ".__i_.__ptr_", nullptr, nullptr, + ValueObject::GetValueForExpressionPathOptions() + .DontCheckDotVsArrowSyntax() + .SetSyntheticChildrenTraversal( + ValueObject::GetValueForExpressionPathOptions:: + SyntheticChildrenTraversal::None), + nullptr) + .get(); + if (m_pair_ptr) { + auto __i_(valobj_sp->GetChildMemberWithName(g___i_, true)); + lldb::TemplateArgumentKind kind; + if (!__i_) { + m_pair_ptr = nullptr; + return false; + } + CompilerType pair_type(__i_->GetCompilerType().GetTemplateArgument(0, kind)); + std::string name; uint64_t bit_offset_ptr; uint32_t bitfield_bit_size_ptr; bool is_bitfield_ptr; + pair_type = pair_type.GetFieldAtIndex(0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr); + if (!pair_type) { + m_pair_ptr = nullptr; + return false; + } + + auto addr(m_pair_ptr->GetValueAsUnsigned(LLDB_INVALID_ADDRESS)); + m_pair_ptr = nullptr; + if (addr && addr!=LLDB_INVALID_ADDRESS) { + ClangASTContext *ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(pair_type.GetTypeSystem()); + if (!ast_ctx) + return false; + CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(ConstString(), { + {"ptr0",ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, + {"ptr1",ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, + {"ptr2",ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, + {"cw",ast_ctx->GetBasicType(lldb::eBasicTypeBool)}, + {"payload",pair_type} + }); + DataBufferSP buffer_sp(new DataBufferHeap(tree_node_type.GetByteSize(nullptr),0)); + ProcessSP process_sp(target_sp->GetProcessSP()); + Error error; + process_sp->ReadMemory(addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), error); + if (error.Fail()) + return false; + DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize()); + auto pair_sp = CreateValueObjectFromData("pair", extractor, valobj_sp->GetExecutionContextRef(), tree_node_type); + if (pair_sp) + m_pair_sp = pair_sp->GetChildAtIndex(4,true); + } + } + } + + return false; } -size_t -lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::CalculateNumChildren () -{ - return 2; +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(); +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetChildAtIndex( + size_t idx) { + if (m_pair_ptr) return m_pair_ptr->GetChildAtIndex(idx, true); + if (m_pair_sp) + return m_pair_sp->GetChildAtIndex(idx, true); + return lldb::ValueObjectSP(); } -bool -lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::MightHaveChildren () -{ - return 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; +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; +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) -{ - return (valobj_sp ? new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp) + : nullptr); } /* @@ -325,323 +396,341 @@ lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheti } */ -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - static ConstString g_item_name; - if (!g_item_name) - g_item_name.SetCString("__i"); - return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + static ConstString g_item_name; + if (!g_item_name) + g_item_name.SetCString("__i"); + return (valobj_sp + ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) + : nullptr); } -lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_cntrl(nullptr), - m_count_sp(), - m_weak_count_sp(), - m_ptr_size(0), - m_byte_order(lldb::eByteOrderInvalid) -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: + LibcxxSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_cntrl(nullptr), 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); +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) +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(); - - 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; + 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()); } - 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; + 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 = nullptr; - - 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 +bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() { + m_count_sp.reset(); + m_weak_count_sp.reset(); + m_cntrl = nullptr; + + 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; +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; +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() = default; +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: + ~LibcxxSharedPtrSyntheticFrontEnd() = default; -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp) + : nullptr); } -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, nullptr, nullptr, nullptr, &valobj, false, false); +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, nullptr, + nullptr, nullptr, &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 +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) +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; - - 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; } + + 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; - 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; +bool lldb_private::formatters::LibcxxWStringSummaryProvider( + ValueObject &valobj, Stream &stream, + const TypeSummaryOptions &summary_options) { + uint64_t size = 0; + ValueObjectSP location_sp; + 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; - - 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(nullptr); - options.SetQuote('"'); - options.SetSourceSize(size); - options.SetBinaryZeroIsTerminator(false); - StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::ASCII>(options); - +bool lldb_private::formatters::LibcxxStringSummaryProvider( + ValueObject &valobj, Stream &stream, + const TypeSummaryOptions &summary_options) { + uint64_t size = 0; + ValueObjectSP location_sp; + + 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(nullptr); + options.SetQuote('"'); + options.SetSourceSize(size); + options.SetBinaryZeroIsTerminator(false); + StringPrinter::ReadBufferAndDumpToStream< + StringPrinter::StringElementType::ASCII>(options); + + return true; +} + +class LibcxxFunctionFrontEnd : public SyntheticValueProviderFrontEnd { +public: + LibcxxFunctionFrontEnd(ValueObject &backend) + : SyntheticValueProviderFrontEnd(backend) {} + + lldb::ValueObjectSP GetSyntheticValue() override { + static ConstString g___f_("__f_"); + return m_backend.GetChildMemberWithName(g___f_, true); + } +}; + +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxFunctionFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + if (valobj_sp) + return new LibcxxFunctionFrontEnd(*valobj_sp); + return nullptr; } diff --git a/source/Plugins/Language/CPlusPlus/LibCxx.h b/source/Plugins/Language/CPlusPlus/LibCxx.h index ae00bc0ade34..a8638513376c 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxx.h +++ b/source/Plugins/Language/CPlusPlus/LibCxx.h @@ -1,4 +1,5 @@ -//===-- LibCxx.h ---------------------------------------------------*- C++ -*-===// +//===-- LibCxx.h ---------------------------------------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -16,126 +17,133 @@ #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 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; + lldb::ValueObjectSP m_pair_sp; +}; + +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); + +SyntheticChildrenFrontEnd *LibcxxFunctionFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); + +} // namespace formatters } // namespace lldb_private #endif // liblldb_LibCxx_h_ diff --git a/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp index a20d7f7d9871..dea52e2f30b6 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp @@ -1,4 +1,5 @@ -//===-- LibCxxAtomic.cpp ------------------------------------------*- C++ -*-===// +//===-- LibCxxAtomic.cpp ------------------------------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -13,109 +14,92 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; -bool -lldb_private::formatters::LibCxxAtomicSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) -{ - static ConstString g___a_("__a_"); - - if (ValueObjectSP child = valobj.GetChildMemberWithName(g___a_, true)) - { - std::string summary; - if (child->GetSummaryAsCString(summary, options) && summary.size() > 0) - { - stream.Printf("%s", summary.c_str()); - return true; - } +bool lldb_private::formatters::LibCxxAtomicSummaryProvider( + ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { + static ConstString g___a_("__a_"); + + if (ValueObjectSP child = valobj.GetChildMemberWithName(g___a_, true)) { + std::string summary; + if (child->GetSummaryAsCString(summary, options) && summary.size() > 0) { + stream.Printf("%s", summary.c_str()); + return true; } - - return false; + } + + return false; } namespace lldb_private { - namespace formatters { - class LibcxxStdAtomicSyntheticFrontEnd : public SyntheticChildrenFrontEnd - { - public: - LibcxxStdAtomicSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); - - ~LibcxxStdAtomicSyntheticFrontEnd() 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; - - lldb::ValueObjectSP - GetSyntheticValue () override; - private: - ValueObject *m_real_child; - }; - } // namespace formatters +namespace formatters { +class LibcxxStdAtomicSyntheticFrontEnd : public SyntheticChildrenFrontEnd { +public: + LibcxxStdAtomicSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); + + ~LibcxxStdAtomicSyntheticFrontEnd() 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; + + lldb::ValueObjectSP GetSyntheticValue() override; + +private: + ValueObject *m_real_child; +}; +} // namespace formatters } // namespace lldb_private -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::LibcxxStdAtomicSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_real_child(nullptr) -{ -} +lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: + LibcxxStdAtomicSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_real_child(nullptr) {} -bool -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::Update() -{ - static ConstString g___a_("__a_"); +bool lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::Update() { + static ConstString g___a_("__a_"); - m_real_child = m_backend.GetChildMemberWithName(g___a_, true).get(); - - return false; + m_real_child = m_backend.GetChildMemberWithName(g___a_, true).get(); + + return false; } -bool -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::MightHaveChildren() -{ - return true; +bool lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: + MightHaveChildren() { + return true; } -size_t -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::CalculateNumChildren() -{ - return m_real_child ? m_real_child->GetNumChildren() : 0; +size_t lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: + CalculateNumChildren() { + return m_real_child ? m_real_child->GetNumChildren() : 0; } lldb::ValueObjectSP -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::GetChildAtIndex(size_t idx) -{ - return m_real_child ? m_real_child->GetChildAtIndex(idx, true) : nullptr; +lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::GetChildAtIndex( + size_t idx) { + return m_real_child ? m_real_child->GetChildAtIndex(idx, true) : nullptr; } -size_t -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) -{ - return m_real_child ? m_real_child->GetIndexOfChildWithName(name) : UINT32_MAX; +size_t lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: + GetIndexOfChildWithName(const ConstString &name) { + return m_real_child ? m_real_child->GetIndexOfChildWithName(name) + : UINT32_MAX; } -lldb::ValueObjectSP -lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::GetSyntheticValue () -{ - if (m_real_child && m_real_child->CanProvideValue()) - return m_real_child->GetSP(); - return nullptr; +lldb::ValueObjectSP lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: + GetSyntheticValue() { + if (m_real_child && m_real_child->CanProvideValue()) + return m_real_child->GetSP(); + return nullptr; } -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - if (valobj_sp) - return new LibcxxStdAtomicSyntheticFrontEnd(valobj_sp); - return nullptr; +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + if (valobj_sp) + return new LibcxxStdAtomicSyntheticFrontEnd(valobj_sp); + return nullptr; } - diff --git a/source/Plugins/Language/CPlusPlus/LibCxxAtomic.h b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.h index 5cf729bfa45f..e2cc01150a2e 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxAtomic.h +++ b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.h @@ -1,4 +1,5 @@ -//===-- LibCxxAtomic.h -------------------------------------------*- C++ -*-===// +//===-- LibCxxAtomic.h -------------------------------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -16,14 +17,15 @@ #include "lldb/DataFormatters/TypeSynthetic.h" namespace lldb_private { - namespace formatters - { - bool - LibCxxAtomicSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); - - SyntheticChildrenFrontEnd* LibcxxAtomicSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); - - } // namespace formatters +namespace formatters { +bool LibCxxAtomicSummaryProvider(ValueObject &valobj, Stream &stream, + const TypeSummaryOptions &options); + +SyntheticChildrenFrontEnd * +LibcxxAtomicSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); + +} // namespace formatters } // namespace lldb_private #endif // liblldb_LibCxxAtomic_h_ diff --git a/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp b/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp index 54fddd15dd0b..b7aa70c0d2e7 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp @@ -22,115 +22,108 @@ 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; - }; - } // namespace formatters +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; +}; +} // namespace formatters } // namespace lldb_private -lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_start(nullptr), - m_element_type(), - m_element_size(0), - m_num_elements(0) -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd:: + LibcxxInitializerListSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_start(nullptr), m_element_type(), + m_element_size(0), m_num_elements(0) { + 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; +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; +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(); - - uint64_t offset = idx * m_element_size; - offset = offset + m_start->GetValueAsUnsigned(0); - StreamString name; - name.Printf("[%" PRIu64 "]", (uint64_t)idx); - return CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type); +lldb::ValueObjectSP lldb_private::formatters:: + LibcxxInitializerListSyntheticFrontEnd::GetChildAtIndex(size_t idx) { + if (!m_start) + return lldb::ValueObjectSP(); + + uint64_t offset = idx * m_element_size; + offset = offset + m_start->GetValueAsUnsigned(0); + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + return CreateValueObjectFromAddress(name.GetString(), offset, + m_backend.GetExecutionContextRef(), + m_element_type); } -bool -lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::Update() -{ - static ConstString g___begin_("__begin_"); - - m_start = nullptr; - m_num_elements = 0; - lldb::TemplateArgumentKind kind; - m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind); - if (kind != lldb::eTemplateArgumentKindType || !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 +bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd:: + Update() { + static ConstString g___begin_("__begin_"); + m_start = nullptr; + m_num_elements = 0; + lldb::TemplateArgumentKind kind; + m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind); + if (kind != lldb::eTemplateArgumentKindType || !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; +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()); +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) -{ - return (valobj_sp ? new LibcxxInitializerListSyntheticFrontEnd(valobj_sp) : nullptr); +lldb_private::SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxInitializerListSyntheticFrontEnd(valobj_sp) + : nullptr); } diff --git a/source/Plugins/Language/CPlusPlus/LibCxxList.cpp b/source/Plugins/Language/CPlusPlus/LibCxxList.cpp index 35cee566a773..16bd631a6c2f 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxList.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxList.cpp @@ -29,380 +29,331 @@ using namespace lldb_private::formatters; namespace { - class ListEntry - { - public: - ListEntry() = default; - ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} - ListEntry(const ListEntry& rhs) = default; - 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() && !null(); - } - - 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) = default; - 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; - }; +class ListEntry { +public: + ListEntry() = default; + ListEntry(ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} + ListEntry(const ListEntry &rhs) = default; + ListEntry(ValueObject *entry) + : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {} + + ListEntry next() { + static ConstString g_next("__next_"); + + if (!m_entry_sp) + return ListEntry(); + return ListEntry(m_entry_sp->GetChildMemberWithName(g_next, true)); + } + + ListEntry prev() { + static ConstString g_prev("__prev_"); + + if (!m_entry_sp) + return ListEntry(); + return ListEntry(m_entry_sp->GetChildMemberWithName(g_prev, true)); + } + + 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() && !null(); } + + 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) = default; + 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, ListIterator> m_iterators; - }; - } // namespace formatters +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, ListIterator> m_iterators; +}; +} // namespace formatters } // namespace lldb_private -lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_list_capping_size(0), - m_loop_detected(0), - m_node_address(), - m_head(nullptr), - m_tail(nullptr), - m_element_type(), - m_count(UINT32_MAX), - m_iterators() -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd:: + LibcxxStdListSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_list_capping_size(0), + m_loop_detected(0), m_node_address(), m_head(nullptr), m_tail(nullptr), + m_element_type(), m_count(UINT32_MAX), m_iterators() { + if (valobj_sp) + Update(); } -bool -lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop(size_t count) -{ - if (!g_use_loop_detect) - 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; - } +bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop( + size_t count) { + if (!g_use_loop_detect) + return false; + // don't bother checking for a loop if we won't actually need to jump nodes + if (m_count < 2) + return false; - // 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; + 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); - } +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); + } + 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(); - - 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; - } +lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex( + size_t idx) { + static ConstString g_value("__value_"); + static ConstString g_next("__next_"); + + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + + if (!m_head || !m_tail || m_node_address == 0) + return lldb::ValueObjectSP(); + + 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 CreateValueObjectFromData(name.GetData(), - data, - m_backend.GetExecutionContextRef(), - m_element_type); + } + + 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(); + + if (current_sp->GetName() == g_next) { + ProcessSP process_sp(current_sp->GetProcessSP()); + if (!process_sp) + return nullptr; + + // if we grabbed the __next_ pointer, then the child is one pointer deep-er + lldb::addr_t addr = current_sp->GetParent()->GetPointerValue(); + addr = addr + 2 * process_sp->GetAddressByteSize(); + ExecutionContext exe_ctx(process_sp); + current_sp = + CreateValueObjectFromAddress("__value_", addr, exe_ctx, m_element_type); + } + + // 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 CreateValueObjectFromData(name.GetString(), data, + m_backend.GetExecutionContextRef(), + m_element_type); } -bool -lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() -{ - m_iterators.clear(); - m_head = m_tail = nullptr; - 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) - 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(); +bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() { + m_iterators.clear(); + m_head = m_tail = nullptr; + 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) + 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; +bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd:: + MightHaveChildren() { + return true; } -size_t -lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) -{ - return ExtractIndexFromString(name.GetCString()); +size_t lldb_private::formatters::LibcxxStdListSyntheticFrontEnd:: + GetIndexOfChildWithName(const ConstString &name) { + return ExtractIndexFromString(name.GetCString()); } -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibcxxStdListSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxStdListSyntheticFrontEnd(valobj_sp) : nullptr); } diff --git a/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp b/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp index d89869283cd3..759a7008d3f3 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp @@ -1,4 +1,4 @@ -//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===// +//===-- LibCxxMap.cpp -------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -27,442 +27,428 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; -class MapEntry -{ +class MapEntry { public: - MapEntry() = default; - explicit MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} - MapEntry(const MapEntry& rhs) = default; - 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()); - } - + MapEntry() = default; + explicit MapEntry(ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} + MapEntry(const MapEntry &rhs) = default; + 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->GetSyntheticChildAtOffset( + 0, m_entry_sp->GetCompilerType(), true); + } + + ValueObjectSP right() const { + static ConstString g_right("__right_"); + if (!m_entry_sp) + return m_entry_sp; + return m_entry_sp->GetSyntheticChildAtOffset( + m_entry_sp->GetProcessSP()->GetAddressByteSize(), + m_entry_sp->GetCompilerType(), true); + } + + ValueObjectSP parent() const { + static ConstString g_parent("__parent_"); + if (!m_entry_sp) + return m_entry_sp; + return m_entry_sp->GetSyntheticChildAtOffset( + 2 * m_entry_sp->GetProcessSP()->GetAddressByteSize(), + m_entry_sp->GetCompilerType(), 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; + ValueObjectSP m_entry_sp; }; -class MapIterator -{ +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; - 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(); + 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; + 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()) - { - 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()); + void next() { + if (m_entry.null()) + return; + MapEntry right(m_entry.right()); + if (!right.null()) { + m_entry = tree_min(std::move(right)); + return; } - -private: - MapEntry - tree_min (MapEntry&& x) - { - if (x.null()) - return MapEntry(); - MapEntry left(x.left()); - size_t steps = 0; - while (!left.null()) - { - if (left.error()) - { - m_error = true; - return MapEntry(); - } - x = left; - left.SetEntry(x.left()); - steps++; - if (steps > m_max_depth) - return MapEntry(); - } - return x; + 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; + } } - - 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(); + 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()) { + if (left.error()) { + m_error = true; + return MapEntry(); + } + x = left; + left.SetEntry(x.left()); + steps++; + if (steps > m_max_depth) + return MapEntry(); } - - MapEntry m_entry; - size_t m_max_depth; - bool m_error; + 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, MapIterator> m_iterators; - }; - } // namespace formatters +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, MapIterator> m_iterators; +}; +} // namespace formatters } // namespace lldb_private -lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_tree(nullptr), - m_root_node(nullptr), - m_element_type(), - m_skip_size(UINT32_MAX), - m_count(UINT32_MAX), - m_iterators() -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd:: + LibcxxStdMapSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_tree(nullptr), + m_root_node(nullptr), m_element_type(), m_skip_size(UINT32_MAX), + m_count(UINT32_MAX), 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 == nullptr) - 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); +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 == nullptr) + 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; +bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() { + static ConstString g___value_("__value_"); + static ConstString g_tree_("__tree_"); + static ConstString g_pair3("__pair3_"); + + 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) { m_element_type = deref->GetCompilerType(); return true; + } + lldb::TemplateArgumentKind kind; + deref = m_backend.GetChildAtNamePath({g_tree_, g_pair3}); + if (!deref) + return false; + m_element_type = + deref->GetCompilerType().GetTemplateArgument(1, kind).GetTemplateArgument( + 1, kind); + if (m_element_type) { + std::string name; + uint64_t bit_offset_ptr; + uint32_t bitfield_bit_size_ptr; + bool is_bitfield_ptr; + m_element_type = m_element_type.GetFieldAtIndex( + 0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr); + m_element_type = m_element_type.GetTypedefedType(); + return m_element_type.IsValid(); + } else { + m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind); + return m_element_type.IsValid(); + } } -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_", nullptr, &bit_offset) == UINT32_MAX) - return; +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_", nullptr, &bit_offset) != + UINT32_MAX) { m_skip_size = bit_offset / 8u; + } else { + ClangASTContext *ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(node_type.GetTypeSystem()); + if (!ast_ctx) + return; + CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier( + ConstString(), + {{"ptr0", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, + {"ptr1", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, + {"ptr2", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, + {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)}, + {"payload", (m_element_type.GetCompleteType(), m_element_type)}}); + std::string child_name; + uint32_t child_byte_size; + int32_t child_byte_offset = 0; + uint32_t child_bitfield_bit_size; + uint32_t child_bitfield_bit_offset; + bool child_is_base_class; + bool child_is_deref_of_parent; + uint64_t language_flags; + if (tree_node_type + .GetChildCompilerTypeAtIndex( + nullptr, 4, true, true, true, child_name, child_byte_size, + child_byte_offset, child_bitfield_bit_size, + child_bitfield_bit_offset, child_is_base_class, + child_is_deref_of_parent, nullptr, language_flags) + .IsValid()) + m_skip_size = (uint32_t)child_byte_offset; + } } 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_"); +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 == nullptr || m_root_node == nullptr) + return lldb::ValueObjectSP(); + + MapIterator iterator(m_root_node, CalculateNumChildren()); - if (idx >= 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) { + // this tree is garbage - stop + m_tree = + nullptr; // 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 = nullptr; return lldb::ValueObjectSP(); - if (m_tree == nullptr || m_root_node == nullptr) + } + GetValueOffset(iterated_sp); + auto child_sp = iterated_sp->GetChildMemberWithName(g___value_, true); + if (child_sp) + iterated_sp = child_sp; + else + iterated_sp = iterated_sp->GetSyntheticChildAtOffset( + m_skip_size, m_element_type, true); + if (!iterated_sp) { + m_tree = nullptr; return lldb::ValueObjectSP(); - - 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) - { - // this tree is garbage - stop - m_tree = nullptr; // 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 = nullptr; - return lldb::ValueObjectSP(); - } - GetValueOffset(iterated_sp); - iterated_sp = iterated_sp->GetChildMemberWithName(g___value_, true); - if (!iterated_sp) - { - m_tree = nullptr; - 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 = nullptr; - return lldb::ValueObjectSP(); - } - iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true); - if (!iterated_sp) - { - m_tree = nullptr; - return lldb::ValueObjectSP(); - } - } - } - else - { + } + } 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 = nullptr; 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()) - { + } + iterated_sp = iterated_sp->GetSyntheticChildAtOffset( + m_skip_size, m_element_type, true); + if (!iterated_sp) { m_tree = nullptr; 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())); + } else { + m_tree = nullptr; + 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 = nullptr; + return lldb::ValueObjectSP(); + } + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + auto potential_child_sp = CreateValueObjectFromData( + name.GetString(), 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; } - m_iterators[idx] = iterator; - return potential_child_sp; + 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.GetString())); + } + m_iterators[idx] = iterator; + return 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 = nullptr; - 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(); +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 = nullptr; + 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; +bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd:: + MightHaveChildren() { + return true; } -size_t -lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) -{ - return ExtractIndexFromString(name.GetCString()); +size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd:: + GetIndexOfChildWithName(const ConstString &name) { + return ExtractIndexFromString(name.GetCString()); } -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibcxxStdMapSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxStdMapSyntheticFrontEnd(valobj_sp) : nullptr); } diff --git a/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp b/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp index a547695448ce..5fe4b3a9fc9e 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp @@ -28,136 +28,162 @@ 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::vector<std::pair<ValueObject*, uint64_t> > m_elements_cache; - }; - } // namespace formatters +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: + CompilerType m_element_type; + CompilerType m_node_type; + ValueObject *m_tree; + size_t m_num_elements; + ValueObject *m_next_element; + 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), - m_tree(nullptr), - m_num_elements(0), - m_next_element(nullptr), - m_elements_cache() -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: + LibcxxStdUnorderedMapSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type(), m_tree(nullptr), + m_num_elements(0), m_next_element(nullptr), 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; +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 == nullptr) - return lldb::ValueObjectSP(); - - 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; +lldb::ValueObjectSP lldb_private::formatters:: + LibcxxStdUnorderedMapSyntheticFrontEnd::GetChildAtIndex(size_t idx) { + if (idx >= CalculateNumChildren()) + return lldb::ValueObjectSP(); + if (m_tree == nullptr) + return lldb::ValueObjectSP(); + + while (idx >= m_elements_cache.size()) { + if (m_next_element == nullptr) + return lldb::ValueObjectSP(); + 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 CreateValueObjectFromData(stream.GetData(), - data, - exe_ctx, - val_hash.first->GetCompilerType()); + 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) { + if (!m_element_type) { + auto first_sp = m_backend.GetChildAtNamePath({ConstString("__table_"), + ConstString("__p1_"), + ConstString("__first_")}); + if (!first_sp) + return nullptr; + m_element_type = first_sp->GetCompilerType(); + lldb::TemplateArgumentKind kind; + m_element_type = m_element_type.GetTemplateArgument(0, kind); + m_element_type = m_element_type.GetPointeeType(); + m_node_type = m_element_type; + m_element_type = m_element_type.GetTemplateArgument(0, kind); + std::string name; + m_element_type = + m_element_type.GetFieldAtIndex(0, name, nullptr, nullptr, nullptr); + m_element_type = m_element_type.GetTypedefedType(); + } + if (!m_node_type) + return nullptr; + node_sp = node_sp->Cast(m_node_type); + value_sp = node_sp->GetChildMemberWithName(ConstString("__value_"), true); + hash_sp = node_sp->GetChildMemberWithName(ConstString("__hash_"), true); + if (!value_sp || !hash_sp) + return nullptr; + } + 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 CreateValueObjectFromData(stream.GetString(), 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(); - 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(); +bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: + Update() { + m_num_elements = UINT32_MAX; + m_next_element = nullptr; + m_elements_cache.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; +bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: + MightHaveChildren() { + return true; } -size_t -lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) -{ - return ExtractIndexFromString(name.GetCString()); +size_t lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: + GetIndexOfChildWithName(const ConstString &name) { + return ExtractIndexFromString(name.GetCString()); } -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp) + : nullptr); } diff --git a/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp b/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp index ed26eaea121c..b5c9b6d0f11e 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp @@ -22,130 +22,120 @@ 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; - }; - } // namespace formatters +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; +}; +} // namespace formatters } // namespace lldb_private -lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_start(nullptr), - m_finish(nullptr), - m_element_type(), - m_element_size(0) -{ - if (valobj_sp) - Update(); +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: + LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_start(nullptr), + m_finish(nullptr), m_element_type(), m_element_size(0) { + 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; +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; +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(); - - uint64_t offset = idx * m_element_size; - offset = offset + m_start->GetValueAsUnsigned(0); - StreamString name; - name.Printf("[%" PRIu64 "]", (uint64_t)idx); - return CreateValueObjectFromAddress(name.GetData(), - offset, - m_backend.GetExecutionContextRef(), - m_element_type); +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex( + size_t idx) { + if (!m_start || !m_finish) + return lldb::ValueObjectSP(); + + uint64_t offset = idx * m_element_size; + offset = offset + m_start->GetValueAsUnsigned(0); + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + return CreateValueObjectFromAddress(name.GetString(), offset, + m_backend.GetExecutionContextRef(), + m_element_type); } -bool -lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() -{ - m_start = m_finish = nullptr; - 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(); - } +bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() { + m_start = m_finish = nullptr; + 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; +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()); +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) -{ - return (valobj_sp ? new LibcxxStdVectorSyntheticFrontEnd(valobj_sp) : nullptr); +lldb_private::SyntheticChildrenFrontEnd * +lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibcxxStdVectorSyntheticFrontEnd(valobj_sp) + : nullptr); } diff --git a/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp b/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp index 6d6f915f68e2..f931a8d6a046 100644 --- a/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp +++ b/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp @@ -28,449 +28,404 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; -namespace -{ - -class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd -{ - /* - (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 - } - } - */ +namespace { + +class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd { + /* + (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 + } + } + */ public: - explicit 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; - + explicit 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; + private: - ExecutionContextRef m_exe_ctx_ref; - lldb::addr_t m_pair_address; - CompilerType m_pair_type; - lldb::ValueObjectSP m_pair_sp; + ExecutionContextRef m_exe_ctx_ref; + lldb::addr_t m_pair_address; + CompilerType m_pair_type; + lldb::ValueObjectSP m_pair_sp; }; -class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd -{ +class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd { public: - explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); + explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); - size_t - CalculateNumChildren() override; + size_t CalculateNumChildren() override; - lldb::ValueObjectSP - GetChildAtIndex(size_t idx) override; + lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; - bool - Update() override; + bool Update() override; - bool - MightHaveChildren() override; + bool MightHaveChildren() override; - size_t - GetIndexOfChildWithName(const ConstString &name) override; + size_t GetIndexOfChildWithName(const ConstString &name) override; }; } // end of anonymous namespace -LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_exe_ctx_ref(), - m_pair_address(0), - m_pair_type(), - m_pair_sp() -{ - if (valobj_sp) - Update(); +LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd( + lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0), + m_pair_type(), m_pair_sp() { + if (valobj_sp) + Update(); } -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; +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; +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(); +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; -} +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; +size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName( + const ConstString &name) { + if (name == ConstString("first")) + return 0; + if (name == ConstString("second")) + return 1; + return UINT32_MAX; } -SyntheticChildrenFrontEnd* -lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp) : nullptr); +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp) + : nullptr); } /* (lldb) fr var ibeg --ptr-depth 1 - (__gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >) ibeg = { + (__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"); - return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) : nullptr); +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"); + return (valobj_sp + ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) + : nullptr); } -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp, - ConstString item_name) : - SyntheticChildrenFrontEnd(*valobj_sp), - m_exe_ctx_ref(), - m_item_name(item_name), - m_item_sp() -{ - if (valobj_sp) - Update(); +lldb_private::formatters::VectorIteratorSyntheticFrontEnd:: + VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp, + ConstString item_name) + : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), + m_item_name(item_name), m_item_sp() { + if (valobj_sp) + Update(); } -bool -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(); +bool VectorIteratorSyntheticFrontEnd::Update() { + m_item_sp.reset(); + + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) return false; -} -size_t -VectorIteratorSyntheticFrontEnd::CalculateNumChildren() -{ - return 1; + 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 VectorIteratorSyntheticFrontEnd::CalculateNumChildren() { return 1; } + lldb::ValueObjectSP -VectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) -{ - if (idx == 0) - return m_item_sp; - return lldb::ValueObjectSP(); +VectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) { + if (idx == 0) + return m_item_sp; + return lldb::ValueObjectSP(); } -bool -VectorIteratorSyntheticFrontEnd::MightHaveChildren() -{ - return true; -} +bool VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; } -size_t -VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) -{ - if (name == ConstString("item")) - return 0; - return UINT32_MAX; +size_t VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName( + const ConstString &name) { + if (name == ConstString("item")) + return 0; + return UINT32_MAX; } -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; - } +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; + } + 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; - } +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; + } + return false; } -LibStdcppSharedPtrSyntheticFrontEnd::LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) - : SyntheticChildrenFrontEnd(*valobj_sp) -{ - if (valobj_sp) - Update(); +LibStdcppSharedPtrSyntheticFrontEnd::LibStdcppSharedPtrSyntheticFrontEnd( + lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp) { + if (valobj_sp) + Update(); } -size_t -LibStdcppSharedPtrSyntheticFrontEnd::CalculateNumChildren() -{ - return 1; -} +size_t LibStdcppSharedPtrSyntheticFrontEnd::CalculateNumChildren() { return 1; } lldb::ValueObjectSP -LibStdcppSharedPtrSyntheticFrontEnd::GetChildAtIndex(size_t idx) -{ - ValueObjectSP valobj_sp = m_backend.GetSP(); - if (!valobj_sp) - return lldb::ValueObjectSP(); - - if (idx == 0) - return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true); - else - return lldb::ValueObjectSP(); -} +LibStdcppSharedPtrSyntheticFrontEnd::GetChildAtIndex(size_t idx) { + ValueObjectSP valobj_sp = m_backend.GetSP(); + if (!valobj_sp) + return lldb::ValueObjectSP(); -bool -LibStdcppSharedPtrSyntheticFrontEnd::Update() -{ - return false; + if (idx == 0) + return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true); + else + return lldb::ValueObjectSP(); } -bool -LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() -{ - return true; -} +bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; } + +bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; } -size_t -LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) -{ - if (name == ConstString("_M_ptr")) - return 0; - return UINT32_MAX; +size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName( + const ConstString &name) { + if (name == ConstString("_M_ptr")) + return 0; + return UINT32_MAX; } SyntheticChildrenFrontEnd * -lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator(CXXSyntheticChildren *, - lldb::ValueObjectSP valobj_sp) -{ - return (valobj_sp ? new LibStdcppSharedPtrSyntheticFrontEnd(valobj_sp) : nullptr); +lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibStdcppSharedPtrSyntheticFrontEnd(valobj_sp) + : nullptr); } -bool -lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(ValueObject &valobj, Stream &stream, - const TypeSummaryOptions &options) -{ - ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); - if (!valobj_sp) - return false; - - ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true)); - if (!ptr_sp) - return false; +bool lldb_private::formatters::LibStdcppSmartPointerSummaryProvider( + ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { + ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); + if (!valobj_sp) + return false; - ValueObjectSP usecount_sp( - valobj_sp->GetChildAtNamePath({ConstString("_M_refcount"), ConstString("_M_pi"), ConstString("_M_use_count")})); - if (!usecount_sp) - return false; + ValueObjectSP ptr_sp( + valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true)); + if (!ptr_sp) + return false; - if (ptr_sp->GetValueAsUnsigned(0) == 0 || usecount_sp->GetValueAsUnsigned(0) == 0) - { - stream.Printf("nullptr"); - return true; - } + ValueObjectSP usecount_sp(valobj_sp->GetChildAtNamePath( + {ConstString("_M_refcount"), ConstString("_M_pi"), + ConstString("_M_use_count")})); + if (!usecount_sp) + return 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)) - { - return true; - } + if (ptr_sp->GetValueAsUnsigned(0) == 0 || + usecount_sp->GetValueAsUnsigned(0) == 0) { + stream.Printf("nullptr"); + return true; + } + + Error error; + ValueObjectSP pointee_sp = ptr_sp->Dereference(error); + if (pointee_sp && error.Success()) { + if (pointee_sp->DumpPrintableRepresentation( + stream, ValueObject::eValueObjectRepresentationStyleSummary, + lldb::eFormatInvalid, + ValueObject::PrintableRepresentationSpecialCases::eDisable, + false)) { + return true; } + } - stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0)); - return true; + stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0)); + return true; } diff --git a/source/Plugins/Language/CPlusPlus/LibStdcpp.h b/source/Plugins/Language/CPlusPlus/LibStdcpp.h index b84c0ff831eb..72e169f50395 100644 --- a/source/Plugins/Language/CPlusPlus/LibStdcpp.h +++ b/source/Plugins/Language/CPlusPlus/LibStdcpp.h @@ -1,4 +1,4 @@ -//===-- LibStdCpp.h ---------------------------------------------------*- C++ -*-===// +//===-- LibStdcpp.h ---------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -16,23 +16,45 @@ #include "lldb/DataFormatters/TypeSynthetic.h" namespace lldb_private { - namespace formatters - { - bool - LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libcstdc++ c++11 std::string +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 +bool LibStdcppWStringSummaryProvider( + ValueObject &valobj, Stream &stream, + const TypeSummaryOptions &options); // libcstdc++ c++11 std::wstring - bool - LibStdcppSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libstdc++ std::shared_ptr<> and std::weak_ptr<> +bool LibStdcppSmartPointerSummaryProvider( + ValueObject &valobj, Stream &stream, + const TypeSummaryOptions + &options); // libstdc++ std::shared_ptr<> and std::weak_ptr<> - SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); +bool LibStdcppUniquePointerSummaryProvider( + ValueObject &valobj, Stream &stream, + const TypeSummaryOptions &options); // libstdc++ std::unique_ptr<> - SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); +SyntheticChildrenFrontEnd * +LibstdcppMapIteratorSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); - SyntheticChildrenFrontEnd* LibStdcppSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); - } // namespace formatters +SyntheticChildrenFrontEnd * +LibStdcppTupleSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); + +SyntheticChildrenFrontEnd * +LibStdcppVectorIteratorSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); + +SyntheticChildrenFrontEnd * +LibStdcppSharedPtrSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); + +SyntheticChildrenFrontEnd * +LibStdcppUniquePtrSyntheticFrontEndCreator(CXXSyntheticChildren *, + lldb::ValueObjectSP); + +} // namespace formatters } // namespace lldb_private #endif // liblldb_LibStdCpp_h_ diff --git a/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp b/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp new file mode 100644 index 000000000000..c4a6e3d227b0 --- /dev/null +++ b/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp @@ -0,0 +1,109 @@ +//===-- LibStdcppTuple.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/ConstString.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +#include <memory> +#include <vector> + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace { + +class LibStdcppTupleSyntheticFrontEnd : public SyntheticChildrenFrontEnd { +public: + explicit LibStdcppTupleSyntheticFrontEnd(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; + +private: + std::vector<ValueObjectSP> m_members; +}; + +} // end of anonymous namespace + +LibStdcppTupleSyntheticFrontEnd::LibStdcppTupleSyntheticFrontEnd( + lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp) { + Update(); +} + +bool LibStdcppTupleSyntheticFrontEnd::Update() { + m_members.clear(); + + ValueObjectSP valobj_backend_sp = m_backend.GetSP(); + if (!valobj_backend_sp) + return false; + + ValueObjectSP next_child_sp = valobj_backend_sp->GetNonSyntheticValue(); + while (next_child_sp != nullptr) { + ValueObjectSP current_child = next_child_sp; + next_child_sp = nullptr; + + size_t child_count = current_child->GetNumChildren(); + for (size_t i = 0; i < child_count; ++i) { + ValueObjectSP child_sp = current_child->GetChildAtIndex(i, true); + llvm::StringRef name_str = child_sp->GetName().GetStringRef(); + if (name_str.startswith("std::_Tuple_impl<")) { + next_child_sp = child_sp; + } else if (name_str.startswith("std::_Head_base<")) { + ValueObjectSP value_sp = + child_sp->GetChildMemberWithName(ConstString("_M_head_impl"), true); + if (value_sp) { + StreamString name; + name.Printf("[%zd]", m_members.size()); + value_sp->SetName(ConstString(name.GetString())); + + m_members.push_back(value_sp); + } + } + } + } + + return false; +} + +bool LibStdcppTupleSyntheticFrontEnd::MightHaveChildren() { return true; } + +lldb::ValueObjectSP +LibStdcppTupleSyntheticFrontEnd::GetChildAtIndex(size_t idx) { + if (idx < m_members.size()) + return m_members[idx]; + return lldb::ValueObjectSP(); +} + +size_t LibStdcppTupleSyntheticFrontEnd::CalculateNumChildren() { + return m_members.size(); +} + +size_t LibStdcppTupleSyntheticFrontEnd::GetIndexOfChildWithName( + const ConstString &name) { + return ExtractIndexFromString(name.GetCString()); +} + +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibStdcppTupleSyntheticFrontEnd(valobj_sp) : nullptr); +} diff --git a/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp b/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp new file mode 100644 index 000000000000..4eb3b95afb4e --- /dev/null +++ b/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp @@ -0,0 +1,151 @@ +//===-- LibStdcppUniquePointer.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/ConstString.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +#include <memory> +#include <vector> + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace { + +class LibStdcppUniquePtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd { +public: + explicit LibStdcppUniquePtrSyntheticFrontEnd(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; + + bool GetSummary(Stream &stream, const TypeSummaryOptions &options); + +private: + ValueObjectSP m_ptr_obj; + ValueObjectSP m_obj_obj; + ValueObjectSP m_del_obj; +}; + +} // end of anonymous namespace + +LibStdcppUniquePtrSyntheticFrontEnd::LibStdcppUniquePtrSyntheticFrontEnd( + lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp) { + Update(); +} + +bool LibStdcppUniquePtrSyntheticFrontEnd::Update() { + ValueObjectSP valobj_backend_sp = m_backend.GetSP(); + if (!valobj_backend_sp) + return false; + + ValueObjectSP valobj_sp = valobj_backend_sp->GetNonSyntheticValue(); + if (!valobj_sp) + return false; + + ValueObjectSP tuple_sp = + valobj_sp->GetChildMemberWithName(ConstString("_M_t"), true); + if (!tuple_sp) + return false; + + std::unique_ptr<SyntheticChildrenFrontEnd> tuple_frontend( + LibStdcppTupleSyntheticFrontEndCreator(nullptr, tuple_sp)); + + m_ptr_obj = tuple_frontend->GetChildAtIndex(0); + if (m_ptr_obj) + m_ptr_obj->SetName(ConstString("pointer")); + + m_del_obj = tuple_frontend->GetChildAtIndex(1); + if (m_del_obj) + m_del_obj->SetName(ConstString("deleter")); + + if (m_ptr_obj) { + Error error; + m_obj_obj = m_ptr_obj->Dereference(error); + if (error.Success()) { + m_obj_obj->SetName(ConstString("object")); + } + } + + return false; +} + +bool LibStdcppUniquePtrSyntheticFrontEnd::MightHaveChildren() { return true; } + +lldb::ValueObjectSP +LibStdcppUniquePtrSyntheticFrontEnd::GetChildAtIndex(size_t idx) { + if (idx == 0) + return m_obj_obj; + if (idx == 1) + return m_del_obj; + if (idx == 2) + return m_ptr_obj; + return lldb::ValueObjectSP(); +} + +size_t LibStdcppUniquePtrSyntheticFrontEnd::CalculateNumChildren() { + if (m_del_obj) + return 2; + if (m_ptr_obj && m_ptr_obj->GetValueAsUnsigned(0) != 0) + return 1; + return 0; +} + +size_t LibStdcppUniquePtrSyntheticFrontEnd::GetIndexOfChildWithName( + const ConstString &name) { + if (name == ConstString("obj") || name == ConstString("object")) + return 0; + if (name == ConstString("del") || name == ConstString("deleter")) + return 1; + if (name == ConstString("ptr") || name == ConstString("pointer")) + return 2; + return UINT32_MAX; +} + +bool LibStdcppUniquePtrSyntheticFrontEnd::GetSummary( + Stream &stream, const TypeSummaryOptions &options) { + if (!m_ptr_obj) + return false; + + bool success; + uint64_t ptr_value = m_ptr_obj->GetValueAsUnsigned(0, &success); + if (!success) + return false; + if (ptr_value == 0) + stream.Printf("nullptr"); + else + stream.Printf("0x%" PRIx64, ptr_value); + return true; +} + +SyntheticChildrenFrontEnd * +lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator( + CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { + return (valobj_sp ? new LibStdcppUniquePtrSyntheticFrontEnd(valobj_sp) + : nullptr); +} + +bool lldb_private::formatters::LibStdcppUniquePointerSummaryProvider( + ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { + LibStdcppUniquePtrSyntheticFrontEnd formatter(valobj.GetSP()); + return formatter.GetSummary(stream, options); +} |