diff options
Diffstat (limited to 'source/Plugins/Language')
36 files changed, 1835 insertions, 935 deletions
diff --git a/source/Plugins/Language/CMakeLists.txt b/source/Plugins/Language/CMakeLists.txt index 60b3da2406b6d..725138a56c8ea 100644 --- a/source/Plugins/Language/CMakeLists.txt +++ b/source/Plugins/Language/CMakeLists.txt @@ -1,4 +1,5 @@ add_subdirectory(CPlusPlus) add_subdirectory(Go) +add_subdirectory(Java) add_subdirectory(ObjC) add_subdirectory(ObjCPlusPlus) diff --git a/source/Plugins/Language/CPlusPlus/BlockPointer.cpp b/source/Plugins/Language/CPlusPlus/BlockPointer.cpp new file mode 100644 index 0000000000000..92e30d54f6e11 --- /dev/null +++ b/source/Plugins/Language/CPlusPlus/BlockPointer.cpp @@ -0,0 +1,225 @@ +//===-- BlockPointer.cpp ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "BlockPointer.h" + +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Symbol/ClangASTContext.h" +#include "lldb/Symbol/ClangASTImporter.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Symbol/TypeSystem.h" +#include "lldb/Target/Target.h" + +#include "lldb/Utility/LLDBAssert.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace lldb_private +{ +namespace formatters +{ + +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() 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(); + } + + 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; + } + + // 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; +}; + +} // 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; + } + + 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); + + const char *child_value = qualified_child_representation_sp->GetValueAsCString(); + + s.Printf("%s", child_value); + + return true; +} + +lldb_private::SyntheticChildrenFrontEnd * +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 new file mode 100644 index 0000000000000..5e6c748b5dbb7 --- /dev/null +++ b/source/Plugins/Language/CPlusPlus/BlockPointer.h @@ -0,0 +1,27 @@ +//===-- BlockPointer.h ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_BlockPointer_h_ +#define liblldb_BlockPointer_h_ + +#include "lldb/lldb-forward.h" + +namespace lldb_private +{ +namespace formatters +{ +bool +BlockPointerSummaryProvider(ValueObject &, Stream &, const TypeSummaryOptions &); + +SyntheticChildrenFrontEnd * +BlockPointerSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP); +} // namespace formatters +} // namespace lldb_private + +#endif // liblldb_BlockPointer_h_ diff --git a/source/Plugins/Language/CPlusPlus/CMakeLists.txt b/source/Plugins/Language/CPlusPlus/CMakeLists.txt index 0b0f0f451a8d1..de0dc99d85dd6 100644 --- a/source/Plugins/Language/CPlusPlus/CMakeLists.txt +++ b/source/Plugins/Language/CPlusPlus/CMakeLists.txt @@ -1,7 +1,9 @@ add_lldb_library(lldbPluginCPlusPlusLanguage + BlockPointer.cpp CPlusPlusLanguage.cpp CxxStringTypes.cpp LibCxx.cpp + LibCxxAtomic.cpp LibCxxInitializerList.cpp LibCxxList.cpp LibCxxMap.cpp diff --git a/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp index 09031e2f8064a..33d22bf2e5834 100644 --- a/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp +++ b/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp @@ -1,4 +1,4 @@ -//===-- CPlusPlusLanguage.cpp --------------------------------------*- C++ -*-===// +//===-- CPlusPlusLanguage.cpp -----------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -9,9 +9,17 @@ #include "CPlusPlusLanguage.h" +// C Includes +// C++ Includes +#include <cstring> +#include <cctype> +#include <functional> +#include <mutex> +// Other libraries and framework includes #include "llvm/ADT/StringRef.h" +// Project includes #include "lldb/Core/ConstString.h" #include "lldb/Core/PluginManager.h" #include "lldb/Core/RegularExpression.h" @@ -21,15 +29,12 @@ #include "lldb/DataFormatters/FormattersHelpers.h" #include "lldb/DataFormatters/VectorType.h" +#include "BlockPointer.h" #include "CxxStringTypes.h" #include "LibCxx.h" +#include "LibCxxAtomic.h" #include "LibStdcpp.h" -#include <cstring> -#include <cctype> -#include <functional> -#include <mutex> - using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; @@ -55,10 +60,10 @@ CPlusPlusLanguage::GetPluginNameStatic() return g_name; } - //------------------------------------------------------------------ // PluginInterface protocol //------------------------------------------------------------------ + lldb_private::ConstString CPlusPlusLanguage::GetPluginName() { @@ -74,6 +79,7 @@ CPlusPlusLanguage::GetPluginVersion() //------------------------------------------------------------------ // Static Functions //------------------------------------------------------------------ + Language * CPlusPlusLanguage::CreateInstance (lldb::LanguageType language) { @@ -319,16 +325,13 @@ CPlusPlusLanguage::IsCPPMangledName (const char *name) // this is a C++ mangled name, but we can put that off till there is actually more than one // we care about. - if (name && name[0] == '_' && name[1] == 'Z') - return true; - else - return false; + 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]*)$"); + 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)) { @@ -344,7 +347,6 @@ 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 @@ -364,11 +366,10 @@ public: FindExactMatches (ConstString& type_name, std::vector<ConstString>& equivalents) { - uint32_t count = 0; for (ImplData match = m_impl.FindFirstValueForName(type_name.AsCString()); - match != NULL; + match != nullptr; match = m_impl.FindNextValueForName(match)) { equivalents.push_back(match->value); @@ -387,7 +388,6 @@ public: FindPartialMatches (ConstString& type_name, std::vector<ConstString>& equivalents) { - uint32_t count = 0; const char* type_name_cstr = type_name.AsCString(); @@ -406,11 +406,9 @@ public: } return count; - } private: - std::string& replace (std::string& target, std::string& pattern, std::string& with) @@ -429,14 +427,13 @@ private: const char *matching_key, std::vector<ConstString>& equivalents) { - std::string matching_key_str(matching_key); ConstString original_const(original); uint32_t count = 0; for (ImplData match = m_impl.FindFirstValueForName(matching_key); - match != NULL; + match != nullptr; match = m_impl.FindNextValueForName(match)) { std::string target(original); @@ -470,7 +467,6 @@ GetEquivalentsMap () return g_equivalents_map; } - uint32_t CPlusPlusLanguage::FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents) { @@ -478,8 +474,8 @@ CPlusPlusLanguage::FindEquivalentNames(ConstString type_name, std::vector<ConstS bool might_have_partials= ( count == 0 ) // if we have a full name match just use it - && (strchr(type_name.AsCString(), '<') != NULL // we should only have partial matches when templates are involved, check that we have - && strchr(type_name.AsCString(), '>') != NULL); // angle brackets in the type_name before trying to scan for partial matches + && (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); @@ -508,60 +504,66 @@ LoadLibCxxFormatters (lldb::TypeCategoryImplSP cpp_category_sp) 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::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__1::map<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_synth_flags); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__1::set<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::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); - - cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")), + 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::__1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); + 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); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags); - - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__1::map<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__1::deque<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_summary_flags); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__1::set<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__1::multiset<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__1::multimap<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::unordered containers summary provider", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_summary_flags, true); + 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::__1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::weak_ptr summary provider", ConstString("^std::__1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true); - - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__1::__wrap_iter<.+>$"), stl_synth_flags, true); + AddCXXSummary(cpp_category_sp, lldb_private::formatters::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); - AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags); - AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__1::__map_iterator<.+>$"), stl_synth_flags, true); + AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__(ndk)?1::__wrap_iter<.+>$"), stl_synth_flags, true); - AddFilter(cpp_category_sp, {"__a_"}, "libc++ std::atomic filter", ConstString("^std::__1::atomic<.*>$"), 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); #endif } @@ -648,8 +650,22 @@ LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) "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); #endif } @@ -774,6 +790,25 @@ CPlusPlusLanguage::GetHardcodedSummaries () } 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; @@ -801,8 +836,21 @@ CPlusPlusLanguage::GetHardcodedSynthetics () } 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; } - diff --git a/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp b/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp index 7e8d9582a2b58..a2c45fb998934 100644 --- a/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp +++ b/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp @@ -192,6 +192,14 @@ lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& str 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); @@ -200,5 +208,17 @@ lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& str options.SetSourceSize(1); options.SetBinaryZeroIsTerminator(false); - return StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF16>(options); + 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/LibCxx.cpp b/source/Plugins/Language/CPlusPlus/LibCxx.cpp index 950bd62c5c9fc..beb89b89c635b 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxx.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxx.cpp @@ -9,6 +9,10 @@ #include "LibCxx.h" +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes #include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Error.h" @@ -74,12 +78,12 @@ lldb_private::formatters::LibcxxSmartPointerSummaryProvider (ValueObject& valobj } lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_bool_type(), -m_exe_ctx_ref(), -m_count(0), -m_base_data_address(0), -m_children() + SyntheticChildrenFrontEnd(*valobj_sp), + m_bool_type(), + m_exe_ctx_ref(), + m_count(0), + m_base_data_address(0), + m_children() { if (valobj_sp) { @@ -141,7 +145,7 @@ lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex (si return ValueObjectSP(); } bool bit_set = ((byte & mask) != 0); - DataBufferSP buffer_sp(new DataBufferHeap(m_bool_type.GetByteSize(nullptr),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); @@ -208,15 +212,12 @@ lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetIndexOfChildWith return idx; } -lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd () -{} +lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd() = default; SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp)); + return (valobj_sp ? new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp) : nullptr); } /* @@ -238,8 +239,8 @@ lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSynthetic */ lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_pair_ptr() + SyntheticChildrenFrontEnd(*valobj_sp), + m_pair_ptr() { if (valobj_sp) Update(); @@ -264,11 +265,11 @@ lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() // it if were a ValueObjectSP, we would end up with a loop (iterator -> synthetic -> child -> parent == iterator) // and that would in turn leak memory by never allowing the ValueObjects to die and free their memory m_pair_ptr = valobj_sp->GetValueForExpressionPath(".__i_.__ptr_->__value_", - NULL, - NULL, - NULL, - ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None), - NULL).get(); + nullptr, + nullptr, + nullptr, + ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None), + nullptr).get(); return false; } @@ -312,9 +313,7 @@ lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::~LibCxxMapIterator SyntheticChildrenFrontEnd* lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp)); + return (valobj_sp ? new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp) : nullptr); } /* @@ -332,18 +331,16 @@ lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSynth static ConstString g_item_name; if (!g_item_name) g_item_name.SetCString("__i"); - if (!valobj_sp) - return NULL; - return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name)); + return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) : nullptr); } lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_cntrl(NULL), -m_count_sp(), -m_weak_count_sp(), -m_ptr_size(0), -m_byte_order(lldb::eByteOrderInvalid) + 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(); @@ -404,7 +401,7 @@ lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() { m_count_sp.reset(); m_weak_count_sp.reset(); - m_cntrl = NULL; + m_cntrl = nullptr; ValueObjectSP valobj_sp = m_backend.GetSP(); if (!valobj_sp) @@ -441,15 +438,12 @@ lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetIndexOfChildWithN return UINT32_MAX; } -lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd () -{} +lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd() = default; SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp)); + return (valobj_sp ? new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp) : nullptr); } bool @@ -462,7 +456,7 @@ lldb_private::formatters::LibcxxContainerSummaryProvider (ValueObject& valobj, S return false; stream.Printf("0x%016" PRIx64 " ", value); } - return FormatEntity::FormatStringRef("size=${svar%#}", stream, NULL, NULL, NULL, &valobj, false, false); + 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) @@ -551,7 +545,7 @@ bool lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options) { uint64_t size = 0; - ValueObjectSP location_sp((ValueObject*)nullptr); + ValueObjectSP location_sp; if (!ExtractLibcxxStringInfo(valobj, location_sp, size)) return false; if (size == 0) @@ -613,7 +607,7 @@ bool lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options) { uint64_t size = 0; - ValueObjectSP location_sp((ValueObject*)nullptr); + ValueObjectSP location_sp; if (!ExtractLibcxxStringInfo(valobj, location_sp, size)) return false; @@ -643,7 +637,7 @@ lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stre options.SetData(extractor); options.SetStream(&stream); - options.SetPrefixToken(0); + options.SetPrefixToken(nullptr); options.SetQuote('"'); options.SetSourceSize(size); options.SetBinaryZeroIsTerminator(false); diff --git a/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp new file mode 100644 index 0000000000000..a20d7f7d9871d --- /dev/null +++ b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp @@ -0,0 +1,121 @@ +//===-- LibCxxAtomic.cpp ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "LibCxxAtomic.h" + +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; + } + } + + 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 lldb_private + +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_"); + + m_real_child = m_backend.GetChildMemberWithName(g___a_, true).get(); + + return false; +} + +bool +lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::MightHaveChildren() +{ + return true; +} + +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; +} + +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; +} + +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 new file mode 100644 index 0000000000000..5cf729bfa45fd --- /dev/null +++ b/source/Plugins/Language/CPlusPlus/LibCxxAtomic.h @@ -0,0 +1,29 @@ +//===-- LibCxxAtomic.h -------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_LibCxxAtomic_h_ +#define liblldb_LibCxxAtomic_h_ + +#include "lldb/Core/Stream.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/TypeSynthetic.h" + +namespace lldb_private { + namespace formatters + { + bool + 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 9970d49dac624..54fddd15dd0bc 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp @@ -50,18 +50,16 @@ namespace lldb_private { CompilerType m_element_type; uint32_t m_element_size; size_t m_num_elements; - std::map<size_t,lldb::ValueObjectSP> m_children; }; } // namespace formatters } // namespace lldb_private lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_start(NULL), -m_element_type(), -m_element_size(0), -m_num_elements(0), -m_children() + SyntheticChildrenFrontEnd(*valobj_sp), + m_start(nullptr), + m_element_type(), + m_element_size(0), + m_num_elements(0) { if (valobj_sp) Update(); @@ -90,17 +88,11 @@ lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::GetChildAtInde if (!m_start) return lldb::ValueObjectSP(); - auto cached = m_children.find(idx); - if (cached != m_children.end()) - return cached->second; - uint64_t offset = idx * m_element_size; offset = offset + m_start->GetValueAsUnsigned(0); StreamString name; name.Printf("[%" PRIu64 "]", (uint64_t)idx); - ValueObjectSP child_sp = CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type); - m_children[idx] = child_sp; - return child_sp; + return CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type); } bool @@ -110,10 +102,9 @@ lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::Update() m_start = nullptr; m_num_elements = 0; - m_children.clear(); lldb::TemplateArgumentKind kind; m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind); - if (kind != lldb::eTemplateArgumentKindType || false == m_element_type.IsValid()) + if (kind != lldb::eTemplateArgumentKindType || !m_element_type.IsValid()) return false; m_element_size = m_element_type.GetByteSize(nullptr); @@ -141,7 +132,5 @@ lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::GetIndexOfChil lldb_private::SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxInitializerListSyntheticFrontEnd(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 f86f968ea8573..35cee566a773b 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxList.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxList.cpp @@ -34,7 +34,7 @@ namespace { public: ListEntry() = default; ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} - ListEntry (const ListEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {} + ListEntry(const ListEntry& rhs) = default; ListEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {} ListEntry @@ -69,7 +69,7 @@ namespace { explicit operator bool () { - return GetEntry().get() != nullptr && null() == false; + return GetEntry() && !null(); } ValueObjectSP @@ -106,7 +106,7 @@ namespace { ListIterator() = default; ListIterator (ListEntry entry) : m_entry(entry) {} ListIterator (ValueObjectSP entry) : m_entry(entry) {} - ListIterator (const ListIterator& rhs) : m_entry(rhs.m_entry) {} + ListIterator(const ListIterator& rhs) = default; ListIterator (ValueObject* entry) : m_entry(entry) {} ValueObjectSP @@ -200,23 +200,21 @@ namespace lldb_private { ValueObject* m_tail; CompilerType m_element_type; size_t m_count; - std::map<size_t,lldb::ValueObjectSP> m_children; std::map<size_t, ListIterator> m_iterators; }; } // namespace formatters } // namespace lldb_private lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_list_capping_size(0), -m_loop_detected(0), -m_node_address(), -m_head(NULL), -m_tail(NULL), -m_element_type(), -m_count(UINT32_MAX), -m_children(), -m_iterators() + 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(); @@ -225,7 +223,7 @@ m_iterators() bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop(size_t count) { - if (g_use_loop_detect == false) + 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) @@ -312,10 +310,6 @@ lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex (size_ if (!m_head || !m_tail || m_node_address == 0) return lldb::ValueObjectSP(); - auto cached = m_children.find(idx); - if (cached != m_children.end()) - return cached->second; - if (HasLoop(idx+1)) return lldb::ValueObjectSP(); @@ -350,15 +344,17 @@ lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex (size_ StreamString name; name.Printf("[%" PRIu64 "]", (uint64_t)idx); - return (m_children[idx] = CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type)); + return CreateValueObjectFromData(name.GetData(), + data, + m_backend.GetExecutionContextRef(), + m_element_type); } bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() { - m_children.clear(); m_iterators.clear(); - m_head = m_tail = NULL; + m_head = m_tail = nullptr; m_node_address = 0; m_count = UINT32_MAX; m_loop_detected = 0; @@ -372,7 +368,7 @@ lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() m_list_capping_size = m_backend.GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); if (m_list_capping_size == 0) m_list_capping_size = 255; - if (err.Fail() || backend_addr.get() == NULL) + if (err.Fail() || !backend_addr) return false; m_node_address = backend_addr->GetValueAsUnsigned(0); if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS) @@ -408,7 +404,5 @@ lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetIndexOfChildWithNam SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxStdListSyntheticFrontEnd(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 aa82557edb020..d89869283cd36 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp @@ -32,7 +32,7 @@ class MapEntry public: MapEntry() = default; explicit MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} - MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {} + MapEntry(const MapEntry& rhs) = default; explicit MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {} ValueObjectSP @@ -124,7 +124,7 @@ public: ValueObjectSP advance (size_t count) { - ValueObjectSP fail(nullptr); + ValueObjectSP fail; if (m_error) return fail; size_t steps = 0; @@ -147,7 +147,7 @@ protected: if (m_entry.null()) return; MapEntry right(m_entry.right()); - if (right.null() == false) + if (!right.null()) { m_entry = tree_min(std::move(right)); return; @@ -179,7 +179,7 @@ private: return MapEntry(); MapEntry left(x.left()); size_t steps = 0; - while (left.null() == false) + while (!left.null()) { if (left.error()) { @@ -246,21 +246,19 @@ namespace lldb_private { CompilerType m_element_type; uint32_t m_skip_size; size_t m_count; - std::map<size_t, lldb::ValueObjectSP> m_children; std::map<size_t, MapIterator> m_iterators; }; } // namespace formatters } // namespace lldb_private lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_tree(NULL), -m_root_node(NULL), -m_element_type(), -m_skip_size(UINT32_MAX), -m_count(UINT32_MAX), -m_children(), -m_iterators() + 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(); @@ -274,7 +272,7 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::CalculateNumChildren () if (m_count != UINT32_MAX) return m_count; - if (m_tree == NULL) + if (m_tree == nullptr) return 0; ValueObjectSP m_item(m_tree->GetChildMemberWithName(g___pair3_, true)); if (!m_item) @@ -315,7 +313,7 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset (const l return; CompilerType node_type(node->GetCompilerType()); uint64_t bit_offset; - if (node_type.GetIndexOfFieldWithName("__value_", NULL, &bit_offset) == UINT32_MAX) + if (node_type.GetIndexOfFieldWithName("__value_", nullptr, &bit_offset) == UINT32_MAX) return; m_skip_size = bit_offset / 8u; } @@ -327,16 +325,11 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t static ConstString g___nc("__nc"); static ConstString g___value_("__value_"); - if (idx >= CalculateNumChildren()) return lldb::ValueObjectSP(); - if (m_tree == NULL || m_root_node == NULL) + if (m_tree == nullptr || m_root_node == nullptr) return lldb::ValueObjectSP(); - auto cached = m_children.find(idx); - if (cached != m_children.end()) - return cached->second; - MapIterator iterator(m_root_node, CalculateNumChildren()); const bool need_to_skip = (idx > 0); @@ -352,10 +345,10 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t } ValueObjectSP iterated_sp(iterator.advance(actual_advancde)); - if (iterated_sp.get() == NULL) + if (!iterated_sp) { // this tree is garbage - stop - m_tree = NULL; // this will stop all future searches until an Update() happens + m_tree = nullptr; // this will stop all future searches until an Update() happens return iterated_sp; } if (GetDataType()) @@ -366,14 +359,14 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t iterated_sp = iterated_sp->Dereference(error); if (!iterated_sp || error.Fail()) { - m_tree = NULL; + m_tree = nullptr; return lldb::ValueObjectSP(); } GetValueOffset(iterated_sp); iterated_sp = iterated_sp->GetChildMemberWithName(g___value_, true); if (!iterated_sp) { - m_tree = NULL; + m_tree = nullptr; return lldb::ValueObjectSP(); } } @@ -385,20 +378,20 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t GetChildAtIndex(0); if (m_skip_size == UINT32_MAX) { - m_tree = NULL; + m_tree = nullptr; return lldb::ValueObjectSP(); } iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true); if (!iterated_sp) { - m_tree = NULL; + m_tree = nullptr; return lldb::ValueObjectSP(); } } } else { - m_tree = NULL; + m_tree = nullptr; return lldb::ValueObjectSP(); } // at this point we have a valid @@ -408,7 +401,7 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t iterated_sp->GetData(data, error); if (error.Fail()) { - m_tree = NULL; + m_tree = nullptr; return lldb::ValueObjectSP(); } StreamString name; @@ -438,7 +431,7 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t potential_child_sp->SetName(ConstString(name.GetData())); } m_iterators[idx] = iterator; - return (m_children[idx] = potential_child_sp); + return potential_child_sp; } bool @@ -447,8 +440,7 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() static ConstString g___tree_("__tree_"); static ConstString g___begin_node_("__begin_node_"); m_count = UINT32_MAX; - m_tree = m_root_node = NULL; - m_children.clear(); + m_tree = m_root_node = nullptr; m_iterators.clear(); m_tree = m_backend.GetChildMemberWithName(g___tree_, true).get(); if (!m_tree) @@ -472,7 +464,5 @@ lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxStdMapSyntheticFrontEnd(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 8ad806d52bce3..a547695448ce4 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp @@ -55,19 +55,17 @@ namespace lldb_private { ValueObject* m_tree; size_t m_num_elements; ValueObject* m_next_element; - std::map<size_t,lldb::ValueObjectSP> m_children; std::vector<std::pair<ValueObject*, uint64_t> > m_elements_cache; }; } // namespace formatters } // namespace lldb_private lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_tree(NULL), -m_num_elements(0), -m_next_element(nullptr), -m_children(), -m_elements_cache() + SyntheticChildrenFrontEnd(*valobj_sp), + m_tree(nullptr), + m_num_elements(0), + m_next_element(nullptr), + m_elements_cache() { if (valobj_sp) Update(); @@ -86,13 +84,9 @@ lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetChildAtInde { if (idx >= CalculateNumChildren()) return lldb::ValueObjectSP(); - if (m_tree == NULL) + if (m_tree == nullptr) return lldb::ValueObjectSP(); - auto cached = m_children.find(idx); - if (cached != m_children.end()) - return cached->second; - while (idx >= m_elements_cache.size()) { if (m_next_element == nullptr) @@ -125,10 +119,10 @@ lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetChildAtInde return lldb::ValueObjectSP(); const bool thread_and_frame_only_if_stopped = true; ExecutionContext exe_ctx = val_hash.first->GetExecutionContextRef().Lock(thread_and_frame_only_if_stopped); - return val_hash.first->CreateValueObjectFromData(stream.GetData(), - data, - exe_ctx, - val_hash.first->GetCompilerType()); + return CreateValueObjectFromData(stream.GetData(), + data, + exe_ctx, + val_hash.first->GetCompilerType()); } bool @@ -137,7 +131,6 @@ lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::Update() m_num_elements = UINT32_MAX; m_next_element = nullptr; m_elements_cache.clear(); - m_children.clear(); ValueObjectSP table_sp = m_backend.GetChildMemberWithName(ConstString("__table_"), true); if (!table_sp) return false; @@ -166,7 +159,5 @@ lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetIndexOfChil SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxStdUnorderedMapSyntheticFrontEnd(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 9fb4f48e90907..ed26eaea121c6 100644 --- a/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp +++ b/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp @@ -50,18 +50,16 @@ namespace lldb_private { ValueObject* m_finish; CompilerType m_element_type; uint32_t m_element_size; - std::map<size_t,lldb::ValueObjectSP> m_children; }; } // namespace formatters } // namespace lldb_private lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_start(NULL), -m_finish(NULL), -m_element_type(), -m_element_size(0), -m_children() + SyntheticChildrenFrontEnd(*valobj_sp), + m_start(nullptr), + m_finish(nullptr), + m_element_type(), + m_element_size(0) { if (valobj_sp) Update(); @@ -100,24 +98,20 @@ lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex (siz if (!m_start || !m_finish) return lldb::ValueObjectSP(); - auto cached = m_children.find(idx); - if (cached != m_children.end()) - return cached->second; - uint64_t offset = idx * m_element_size; offset = offset + m_start->GetValueAsUnsigned(0); StreamString name; name.Printf("[%" PRIu64 "]", (uint64_t)idx); - ValueObjectSP child_sp = CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type); - m_children[idx] = child_sp; - return child_sp; + return CreateValueObjectFromAddress(name.GetData(), + offset, + m_backend.GetExecutionContextRef(), + m_element_type); } bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() { - m_start = m_finish = NULL; - m_children.clear(); + m_start = m_finish = nullptr; ValueObjectSP data_type_finder_sp(m_backend.GetChildMemberWithName(ConstString("__end_cap_"),true)); if (!data_type_finder_sp) return false; @@ -153,7 +147,5 @@ lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetIndexOfChildWithN lldb_private::SyntheticChildrenFrontEnd* lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibcxxStdVectorSyntheticFrontEnd(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 ed89c5c84ea3a..6d6f915f68e20 100644 --- a/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp +++ b/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp @@ -1,4 +1,4 @@ -//===-- LibStdcpp.cpp ---------------------------------------------*- C++ -*-===// +//===-- LibStdcpp.cpp -------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -9,6 +9,10 @@ #include "LibStdcpp.h" +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes #include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/Error.h" #include "lldb/Core/Stream.h" @@ -24,11 +28,25 @@ 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 + } + } + */ + public: - LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); - + explicit LibstdcppMapIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); + size_t CalculateNumChildren() override; @@ -44,41 +62,45 @@ public: size_t GetIndexOfChildWithName (const ConstString &name) override; - ~LibstdcppMapIteratorSyntheticFrontEnd() override; - private: ExecutionContextRef m_exe_ctx_ref; lldb::addr_t m_pair_address; CompilerType m_pair_type; - EvaluateExpressionOptions m_options; lldb::ValueObjectSP m_pair_sp; }; -/* - (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ibeg = { - (_Base_ptr) _M_node = 0x0000000100103910 { - (std::_Rb_tree_color) _M_color = _S_black - (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0 - (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000 - (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000 - } - } - */ +class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + explicit LibStdcppSharedPtrSyntheticFrontEnd(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; +}; + +} // end of anonymous namespace LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp.get()), + SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0), m_pair_type(), - m_options(), m_pair_sp() { if (valobj_sp) Update(); - m_options.SetCoerceToId(false); - m_options.SetUnwindOnError(true); - m_options.SetKeepInMemory(true); - m_options.SetUseDynamic(lldb::eDynamicCanRunTarget); } bool @@ -159,15 +181,10 @@ LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstStrin return UINT32_MAX; } -LibstdcppMapIteratorSyntheticFrontEnd::~LibstdcppMapIteratorSyntheticFrontEnd () -{} - SyntheticChildrenFrontEnd* lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) { - if (!valobj_sp) - return NULL; - return (new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp)); + return (valobj_sp ? new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp) : nullptr); } /* @@ -185,24 +202,22 @@ lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSy static ConstString g_item_name; if (!g_item_name) g_item_name.SetCString("_M_current"); - if (!valobj_sp) - return NULL; - return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name)); + 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.get()), -m_exe_ctx_ref(), -m_item_name(item_name), -m_item_sp() + SyntheticChildrenFrontEnd(*valobj_sp), + m_exe_ctx_ref(), + m_item_name(item_name), + m_item_sp() { if (valobj_sp) Update(); } bool -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::Update() +VectorIteratorSyntheticFrontEnd::Update() { m_item_sp.reset(); @@ -227,13 +242,13 @@ lldb_private::formatters::VectorIteratorSyntheticFrontEnd::Update() } size_t -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::CalculateNumChildren () +VectorIteratorSyntheticFrontEnd::CalculateNumChildren() { return 1; } lldb::ValueObjectSP -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx) +VectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) { if (idx == 0) return m_item_sp; @@ -241,23 +256,19 @@ lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetChildAtIndex (size } bool -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::MightHaveChildren () +VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; } size_t -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) { if (name == ConstString("item")) return 0; return UINT32_MAX; } -lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSyntheticFrontEnd () -{ -} - bool lldb_private::formatters::LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) { @@ -371,3 +382,95 @@ lldb_private::formatters::LibStdcppWStringSummaryProvider (ValueObject& valobj, } return false; } + +LibStdcppSharedPtrSyntheticFrontEnd::LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) + : SyntheticChildrenFrontEnd(*valobj_sp) +{ + if (valobj_sp) + Update(); +} + +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(); +} + +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; +} + +SyntheticChildrenFrontEnd * +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; + + ValueObjectSP usecount_sp( + valobj_sp->GetChildAtNamePath({ConstString("_M_refcount"), ConstString("_M_pi"), ConstString("_M_use_count")})); + if (!usecount_sp) + return false; + + 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::ePrintableRepresentationSpecialCasesDisable, false)) + { + 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 347856a1695c4..b84c0ff831eb2 100644 --- a/source/Plugins/Language/CPlusPlus/LibStdcpp.h +++ b/source/Plugins/Language/CPlusPlus/LibStdcpp.h @@ -24,9 +24,14 @@ namespace lldb_private { 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<> + SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); - + SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + + SyntheticChildrenFrontEnd* LibStdcppSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); } // namespace formatters } // namespace lldb_private diff --git a/source/Plugins/Language/CPlusPlus/Makefile b/source/Plugins/Language/CPlusPlus/Makefile deleted file mode 100644 index 2cb0dcf638b3b..0000000000000 --- a/source/Plugins/Language/CPlusPlus/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -##===- source/Plugins/Language/CPlusPlus -------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LLDB_LEVEL := ../../../.. -LIBRARYNAME := lldbPluginCPlusPlusLanguage -BUILD_ARCHIVE = 1 - -include $(LLDB_LEVEL)/Makefile diff --git a/source/Plugins/Language/Go/Makefile b/source/Plugins/Language/Go/Makefile deleted file mode 100644 index 3ea09f6c538f1..0000000000000 --- a/source/Plugins/Language/Go/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -##===- source/Plugins/Language/Go -------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LLDB_LEVEL := ../../../.. -LIBRARYNAME := lldbPluginGoLanguage -BUILD_ARCHIVE = 1 - -include $(LLDB_LEVEL)/Makefile diff --git a/source/Plugins/Language/Java/CMakeLists.txt b/source/Plugins/Language/Java/CMakeLists.txt new file mode 100644 index 0000000000000..80f7b08e7b655 --- /dev/null +++ b/source/Plugins/Language/Java/CMakeLists.txt @@ -0,0 +1,4 @@ +add_lldb_library(lldbPluginJavaLanguage + JavaFormatterFunctions.cpp + JavaLanguage.cpp +) diff --git a/source/Plugins/Language/Java/JavaFormatterFunctions.cpp b/source/Plugins/Language/Java/JavaFormatterFunctions.cpp new file mode 100644 index 0000000000000..29e6ad0ee89f2 --- /dev/null +++ b/source/Plugins/Language/Java/JavaFormatterFunctions.cpp @@ -0,0 +1,186 @@ +//===-- JavaFormatterFunctions.cpp-------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "JavaFormatterFunctions.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/DataFormatters/StringPrinter.h" +#include "lldb/Symbol/JavaASTContext.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +namespace +{ + +class JavaArraySyntheticFrontEnd : public SyntheticChildrenFrontEnd +{ +public: + JavaArraySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd(*valobj_sp) + { + if (valobj_sp) + Update(); + } + + size_t + CalculateNumChildren() override + { + ValueObjectSP valobj = GetDereferencedValueObject(); + if (!valobj) + return 0; + + CompilerType type = valobj->GetCompilerType(); + uint32_t size = JavaASTContext::CalculateArraySize(type, *valobj); + if (size == UINT32_MAX) + return 0; + return size; + } + + lldb::ValueObjectSP + GetChildAtIndex(size_t idx) override + { + ValueObjectSP valobj = GetDereferencedValueObject(); + if (!valobj) + return nullptr; + + ProcessSP process_sp = valobj->GetProcessSP(); + if (!process_sp) + return nullptr; + + CompilerType type = valobj->GetCompilerType(); + CompilerType element_type = type.GetArrayElementType(); + lldb::addr_t address = valobj->GetAddressOf() + JavaASTContext::CalculateArrayElementOffset(type, idx); + + Error error; + size_t byte_size = element_type.GetByteSize(nullptr); + DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0)); + size_t bytes_read = process_sp->ReadMemory(address, buffer_sp->GetBytes(), byte_size, error); + if (error.Fail() || byte_size != bytes_read) + return nullptr; + + StreamString name; + name.Printf("[%" PRIu64 "]", (uint64_t)idx); + DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize()); + return CreateValueObjectFromData(name.GetData(), data, valobj->GetExecutionContextRef(), + element_type); + } + + bool + Update() override + { + return false; + } + + bool + MightHaveChildren() override + { + return true; + } + + size_t + GetIndexOfChildWithName(const ConstString &name) override + { + return ExtractIndexFromString(name.GetCString()); + } + +private: + ValueObjectSP + GetDereferencedValueObject() + { + if (!m_backend.IsPointerOrReferenceType()) + return m_backend.GetSP(); + + Error error; + return m_backend.Dereference(error); + } +}; + +} // end of anonymous namespace + +bool +lldb_private::formatters::JavaStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &opts) +{ + if (valobj.IsPointerOrReferenceType()) + { + Error error; + ValueObjectSP deref = valobj.Dereference(error); + if (error.Fail()) + return false; + return JavaStringSummaryProvider(*deref, stream, opts); + } + + ProcessSP process_sp = valobj.GetProcessSP(); + if (!process_sp) + return false; + + ConstString data_name("value"); + ConstString length_name("count"); + + ValueObjectSP length_sp = valobj.GetChildMemberWithName(length_name, true); + ValueObjectSP data_sp = valobj.GetChildMemberWithName(data_name, true); + if (!data_sp || !length_sp) + return false; + + bool success = false; + uint64_t length = length_sp->GetValueAsUnsigned(0, &success); + if (!success) + return false; + + if (length == 0) + { + stream.Printf("\"\""); + return true; + } + lldb::addr_t valobj_addr = data_sp->GetAddressOf(); + + StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); + options.SetLocation(valobj_addr); + options.SetProcessSP(process_sp); + options.SetStream(&stream); + options.SetSourceSize(length); + options.SetNeedsZeroTermination(false); + options.SetLanguage(eLanguageTypeJava); + + if (StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options)) + return true; + + stream.Printf("Summary Unavailable"); + return true; +} + +bool +lldb_private::formatters::JavaArraySummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) +{ + if (valobj.IsPointerOrReferenceType()) + { + Error error; + ValueObjectSP deref = valobj.Dereference(error); + if (error.Fail()) + return false; + return JavaArraySummaryProvider(*deref, stream, options); + } + + CompilerType type = valobj.GetCompilerType(); + uint32_t size = JavaASTContext::CalculateArraySize(type, valobj); + if (size == UINT32_MAX) + return false; + stream.Printf("[%u]{...}", size); + return true; +} + +SyntheticChildrenFrontEnd* +lldb_private::formatters::JavaArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +{ + return valobj_sp ? new JavaArraySyntheticFrontEnd(valobj_sp) : nullptr; +} diff --git a/source/Plugins/Language/Java/JavaFormatterFunctions.h b/source/Plugins/Language/Java/JavaFormatterFunctions.h new file mode 100644 index 0000000000000..f9588c5590ae0 --- /dev/null +++ b/source/Plugins/Language/Java/JavaFormatterFunctions.h @@ -0,0 +1,36 @@ +//===-- JavaFormatterFunctions.h---------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_JavaFormatterFunctions_h_ +#define liblldb_JavaFormatterFunctions_h_ + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "lldb/lldb-forward.h" + +namespace lldb_private +{ +namespace formatters +{ + +bool +JavaStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options); + +bool +JavaArraySummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options); + +SyntheticChildrenFrontEnd* +JavaArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp); + +} // namespace formatters +} // namespace lldb_private + +#endif // liblldb_JavaFormatterFunctions_h_ diff --git a/source/Plugins/Language/Java/JavaLanguage.cpp b/source/Plugins/Language/Java/JavaLanguage.cpp new file mode 100644 index 0000000000000..a4f883f688279 --- /dev/null +++ b/source/Plugins/Language/Java/JavaLanguage.cpp @@ -0,0 +1,112 @@ +//===-- JavaLanguage.cpp ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +#include <string.h> +// C++ Includes +#include <functional> +#include <mutex> + +// Other libraries and framework includes +#include "llvm/ADT/StringRef.h" + +// Project includes +#include "JavaFormatterFunctions.h" +#include "JavaLanguage.h" +#include "lldb/Core/ConstString.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/DataFormatters/DataVisualization.h" +#include "lldb/DataFormatters/FormattersHelpers.h" +#include "lldb/Symbol/JavaASTContext.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +void +JavaLanguage::Initialize() +{ + PluginManager::RegisterPlugin(GetPluginNameStatic(), "Java Language", CreateInstance); +} + +void +JavaLanguage::Terminate() +{ + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString +JavaLanguage::GetPluginNameStatic() +{ + static ConstString g_name("Java"); + return g_name; +} + +lldb_private::ConstString +JavaLanguage::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +JavaLanguage::GetPluginVersion() +{ + return 1; +} + +Language * +JavaLanguage::CreateInstance(lldb::LanguageType language) +{ + if (language == eLanguageTypeJava) + return new JavaLanguage(); + return nullptr; +} + +bool +JavaLanguage::IsNilReference(ValueObject &valobj) +{ + if (!valobj.GetCompilerType().IsReferenceType()) + return false; + + // If we failed to read the value then it is not a nil reference. + return valobj.GetValueAsUnsigned(UINT64_MAX) == 0; +} + +lldb::TypeCategoryImplSP +JavaLanguage::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) + { + const char* array_regexp = "^.*\\[\\]&?$"; + + lldb::TypeSummaryImplSP string_summary_sp(new CXXFunctionSummaryFormat( + TypeSummaryImpl::Flags().SetDontShowChildren(true), lldb_private::formatters::JavaStringSummaryProvider, + "java.lang.String summary provider")); + g_category->GetTypeSummariesContainer()->Add(ConstString("java::lang::String"), string_summary_sp); + + lldb::TypeSummaryImplSP array_summary_sp(new CXXFunctionSummaryFormat( + TypeSummaryImpl::Flags().SetDontShowChildren(true), lldb_private::formatters::JavaArraySummaryProvider, + "Java array summary provider")); + g_category->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(array_regexp)), + array_summary_sp); + +#ifndef LLDB_DISABLE_PYTHON + AddCXXSynthetic(g_category, lldb_private::formatters::JavaArraySyntheticFrontEndCreator, + "Java array synthetic children", ConstString(array_regexp), + SyntheticChildren::Flags().SetCascades(true), true); +#endif + } + }); + return g_category; +} diff --git a/source/Plugins/Language/Java/JavaLanguage.h b/source/Plugins/Language/Java/JavaLanguage.h new file mode 100644 index 0000000000000..164facd27ab5e --- /dev/null +++ b/source/Plugins/Language/Java/JavaLanguage.h @@ -0,0 +1,64 @@ +//===-- JavaLanguage.h ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_JavaLanguage_h_ +#define liblldb_JavaLanguage_h_ + +// C Includes +// C++ Includes +#include <vector> + +// Other libraries and framework includes +#include "llvm/ADT/StringRef.h" + +// Project includes +#include "lldb/Core/ConstString.h" +#include "lldb/Target/Language.h" +#include "lldb/lldb-private.h" + +namespace lldb_private +{ + +class JavaLanguage : public Language +{ +public: + lldb::LanguageType + GetLanguageType() const override + { + return lldb::eLanguageTypeJava; + } + + static void + Initialize(); + + static void + Terminate(); + + static lldb_private::Language * + CreateInstance(lldb::LanguageType language); + + static lldb_private::ConstString + GetPluginNameStatic(); + + ConstString + GetPluginName() override; + + uint32_t + GetPluginVersion() override; + + bool + IsNilReference(ValueObject &valobj) override; + + lldb::TypeCategoryImplSP + GetFormatters() override; +}; + +} // namespace lldb_private + +#endif // liblldb_JavaLanguage_h_ diff --git a/source/Plugins/Language/ObjC/CF.cpp b/source/Plugins/Language/ObjC/CF.cpp index 614eb29a0f7a4..617bb613aa0b2 100644 --- a/source/Plugins/Language/ObjC/CF.cpp +++ b/source/Plugins/Language/ObjC/CF.cpp @@ -73,37 +73,28 @@ lldb_private::formatters::CFBagSummaryProvider (ValueObject& valobj, Stream& str if (descriptor->IsCFType()) { ConstString type_name(valobj.GetTypeName()); - if (type_name == ConstString("__CFBag") || type_name == ConstString("const struct __CFBag")) + + static ConstString g___CFBag("__CFBag"); + static ConstString g_conststruct__CFBag("const struct __CFBag"); + + if (type_name == g___CFBag || + type_name == g_conststruct__CFBag) { if (valobj.IsPointerType()) is_type_ok = true; } } - if (is_type_ok == false) - { - StackFrameSP frame_sp(valobj.GetFrameSP()); - if (!frame_sp) - return false; - ValueObjectSP count_sp; - StreamString expr; - expr.Printf("(int)CFBagGetCount((void*)0x%" PRIx64 ")",valobj.GetPointerValue()); - EvaluateExpressionOptions options; - options.SetResultIsInternal(true); - if (process_sp->GetTarget().EvaluateExpression(expr.GetData(), frame_sp.get(), count_sp, options) != eExpressionCompleted) - return false; - if (!count_sp) - return false; - count = count_sp->GetValueAsUnsigned(0); - } - else + if (is_type_ok) { - uint32_t offset = 2*ptr_size+4 + valobj_addr; + lldb::addr_t offset = 2*ptr_size+4 + valobj_addr; Error error; count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error); if (error.Fail()) return false; } + else + return false; std::string prefix,suffix; if (Language* language = Language::FindPlugin(options.GetLanguage())) @@ -284,37 +275,30 @@ lldb_private::formatters::CFBinaryHeapSummaryProvider (ValueObject& valobj, Stre if (descriptor->IsCFType()) { ConstString type_name(valobj.GetTypeName()); - if (type_name == ConstString("__CFBinaryHeap") || type_name == ConstString("const struct __CFBinaryHeap")) + + static ConstString g___CFBinaryHeap("__CFBinaryHeap"); + static ConstString g_conststruct__CFBinaryHeap("const struct __CFBinaryHeap"); + static ConstString g_CFBinaryHeapRef("CFBinaryHeapRef"); + + if (type_name == g___CFBinaryHeap || + type_name == g_conststruct__CFBinaryHeap || + type_name == g_CFBinaryHeapRef) { if (valobj.IsPointerType()) is_type_ok = true; } } - if (is_type_ok == false) + if (is_type_ok) { - StackFrameSP frame_sp(valobj.GetFrameSP()); - if (!frame_sp) - return false; - ValueObjectSP count_sp; - StreamString expr; - expr.Printf("(int)CFBinaryHeapGetCount((void*)0x%" PRIx64 ")",valobj.GetPointerValue()); - EvaluateExpressionOptions options; - options.SetResultIsInternal(true); - if (process_sp->GetTarget().EvaluateExpression(expr.GetData(), frame_sp.get(), count_sp, options) != eExpressionCompleted) - return false; - if (!count_sp) - return false; - count = count_sp->GetValueAsUnsigned(0); - } - else - { - uint32_t offset = 2*ptr_size; + lldb::addr_t offset = 2*ptr_size + valobj_addr; Error error; count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error); if (error.Fail()) return false; } + else + return false; std::string prefix,suffix; if (Language* language = Language::FindPlugin(options.GetLanguage())) diff --git a/source/Plugins/Language/ObjC/Cocoa.cpp b/source/Plugins/Language/ObjC/Cocoa.cpp index aa6e476b61319..017c46ee3bb36 100644 --- a/source/Plugins/Language/ObjC/Cocoa.cpp +++ b/source/Plugins/Language/ObjC/Cocoa.cpp @@ -50,7 +50,7 @@ lldb_private::formatters::NSBundleSummaryProvider (ValueObject& valobj, Stream& ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -71,16 +71,15 @@ lldb_private::formatters::NSBundleSummaryProvider (ValueObject& valobj, Stream& ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID), true)); StreamString summary_stream; - bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options); + bool was_nsstring_ok = NSStringSummaryProvider(*text, summary_stream, options); if (was_nsstring_ok && summary_stream.GetSize() > 0) { stream.Printf("%s",summary_stream.GetData()); return true; } } - // this is either an unknown subclass or an NSBundle that comes from [NSBundle mainBundle] - // which is encoded differently and needs to be handled by running code - return ExtractSummaryFromObjCExpression(valobj, "NSString*", "bundlePath", stream, options.GetLanguage()); + + return false; } bool @@ -97,7 +96,7 @@ lldb_private::formatters::NSTimeZoneSummaryProvider (ValueObject& valobj, Stream ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -117,14 +116,15 @@ lldb_private::formatters::NSTimeZoneSummaryProvider (ValueObject& valobj, Stream uint64_t offset = ptr_size; ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType(), true)); StreamString summary_stream; - bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options); + bool was_nsstring_ok = NSStringSummaryProvider(*text, summary_stream, options); if (was_nsstring_ok && summary_stream.GetSize() > 0) { stream.Printf("%s",summary_stream.GetData()); return true; } } - return ExtractSummaryFromObjCExpression(valobj, "NSString*", "name", stream, options.GetLanguage()); + + return false; } bool @@ -141,7 +141,7 @@ lldb_private::formatters::NSNotificationSummaryProvider (ValueObject& valobj, St ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -161,16 +161,15 @@ lldb_private::formatters::NSNotificationSummaryProvider (ValueObject& valobj, St uint64_t offset = ptr_size; ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType(), true)); StreamString summary_stream; - bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options); + bool was_nsstring_ok = NSStringSummaryProvider(*text, summary_stream, options); if (was_nsstring_ok && summary_stream.GetSize() > 0) { stream.Printf("%s",summary_stream.GetData()); return true; } } - // this is either an unknown subclass or an NSBundle that comes from [NSBundle mainBundle] - // which is encoded differently and needs to be handled by running code - return ExtractSummaryFromObjCExpression(valobj, "NSString*", "name", stream, options.GetLanguage()); + + return false; } bool @@ -187,7 +186,7 @@ lldb_private::formatters::NSMachPortSummaryProvider (ValueObject& valobj, Stream ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -204,22 +203,19 @@ lldb_private::formatters::NSMachPortSummaryProvider (ValueObject& valobj, Stream uint64_t port_number = 0; - do + if (!strcmp(class_name,"NSMachPort")) { - if (!strcmp(class_name,"NSMachPort")) + uint64_t offset = (ptr_size == 4 ? 12 : 20); + Error error; + port_number = process_sp->ReadUnsignedIntegerFromMemory(offset+valobj_addr, 4, 0, error); + if (error.Success()) { - uint64_t offset = (ptr_size == 4 ? 12 : 20); - Error error; - port_number = process_sp->ReadUnsignedIntegerFromMemory(offset+valobj_addr, 4, 0, error); - if (error.Success()) - break; + stream.Printf("mach port: %u",(uint32_t)(port_number & 0x00000000FFFFFFFF)); + return true; } - if (!ExtractValueFromObjCExpression(valobj, "int", "machPort", port_number)) - return false; - } while (false); + } - stream.Printf("mach port: %u",(uint32_t)(port_number & 0x00000000FFFFFFFF)); - return true; + return false; } bool @@ -236,7 +232,7 @@ lldb_private::formatters::NSIndexSetSummaryProvider (ValueObject& valobj, Stream ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -289,10 +285,7 @@ lldb_private::formatters::NSIndexSetSummaryProvider (ValueObject& valobj, Stream } } else - { - if (!ExtractValueFromObjCExpression(valobj, "unsigned long long int", "count", count)) - return false; - } + return false; } while (false); stream.Printf("%" PRIu64 " index%s", count, @@ -458,7 +451,7 @@ lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -531,6 +524,7 @@ lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& break; case 17: // 0B10001 data_location += 8; + LLVM_FALLTHROUGH; case 4: // 0B0100 value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, error); if (error.Fail()) @@ -542,7 +536,8 @@ lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& uint32_t flt_as_int = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0, error); if (error.Fail()) return false; - float flt_value = *((float*)&flt_as_int); + float flt_value = 0.0f; + memcpy(&flt_value, &flt_as_int, sizeof(flt_as_int)); NSNumber_FormatFloat(valobj, stream, flt_value, options.GetLanguage()); break; } @@ -551,7 +546,8 @@ lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& uint64_t dbl_as_lng = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, error); if (error.Fail()) return false; - double dbl_value = *((double*)&dbl_as_lng); + double dbl_value = 0.0; + memcpy(&dbl_value, &dbl_as_lng, sizeof(dbl_as_lng)); NSNumber_FormatDouble(valobj, stream, dbl_value, options.GetLanguage()); break; } @@ -561,10 +557,8 @@ lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& return true; } } - else - { - return ExtractSummaryFromObjCExpression(valobj, "NSString*", "stringValue", stream, options.GetLanguage()); - } + + return false; } bool @@ -581,7 +575,7 @@ lldb_private::formatters::NSURLSummaryProvider (ValueObject& valobj, Stream& str ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -625,10 +619,7 @@ lldb_private::formatters::NSURLSummaryProvider (ValueObject& valobj, Stream& str return true; } } - else - { - return ExtractSummaryFromObjCExpression(valobj, "NSString*", "description", stream, options.GetLanguage()); - } + return false; } @@ -646,7 +637,7 @@ lldb_private::formatters::NSDateSummaryProvider (ValueObject& valobj, Stream& st ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -659,44 +650,48 @@ lldb_private::formatters::NSDateSummaryProvider (ValueObject& valobj, Stream& st uint64_t date_value_bits = 0; double date_value = 0.0; - const char* class_name = descriptor->GetClassName().GetCString(); + ConstString class_name = descriptor->GetClassName(); - if (!class_name || !*class_name) + static const ConstString g_NSDate("NSDate"); + static const ConstString g___NSDate("__NSDate"); + static const ConstString g___NSTaggedDate("__NSTaggedDate"); + static const ConstString g_NSCalendarDate("NSCalendarDate"); + + if (class_name.IsEmpty()) return false; - if (strcmp(class_name,"NSDate") == 0 || - strcmp(class_name,"__NSDate") == 0 || - strcmp(class_name,"__NSTaggedDate") == 0) + if ((class_name == g_NSDate) || + (class_name == g___NSDate) || + (class_name == g___NSTaggedDate)) { uint64_t info_bits=0,value_bits = 0; if (descriptor->GetTaggedPointerInfo(&info_bits,&value_bits)) { date_value_bits = ((value_bits << 8) | (info_bits << 4)); - date_value = *((double*)&date_value_bits); + memcpy(&date_value, &date_value_bits, sizeof(date_value_bits)); } else { + llvm::Triple triple(process_sp->GetTarget().GetArchitecture().GetTriple()); + uint32_t delta = (triple.isWatchOS() && triple.isWatchABI()) ? 8 : ptr_size; Error error; - date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+ptr_size, 8, 0, error); - date_value = *((double*)&date_value_bits); + date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+delta, 8, 0, error); + memcpy(&date_value, &date_value_bits, sizeof(date_value_bits)); if (error.Fail()) return false; } } - else if (!strcmp(class_name,"NSCalendarDate")) + else if (class_name == g_NSCalendarDate) { Error error; date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, 8, 0, error); - date_value = *((double*)&date_value_bits); + memcpy(&date_value, &date_value_bits, sizeof(date_value_bits)); if (error.Fail()) return false; } else - { - if (ExtractValueFromObjCExpression(valobj, "NSTimeInterval", "ExtractValueFromObjCExpression", date_value_bits) == false) - return false; - date_value = *((double*)&date_value_bits); - } + return false; + if (date_value == -63114076800) { stream.Printf("0001-12-30 00:00:00 +0000"); @@ -731,7 +726,7 @@ lldb_private::formatters::ObjCClassSummaryProvider (ValueObject& valobj, Stream& ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0))); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; ConstString class_name = descriptor->GetClassName(); @@ -750,7 +745,7 @@ class ObjCClassSyntheticChildrenFrontEnd : public SyntheticChildrenFrontEnd { public: ObjCClassSyntheticChildrenFrontEnd (lldb::ValueObjectSP valobj_sp) : - SyntheticChildrenFrontEnd(*valobj_sp.get()) + SyntheticChildrenFrontEnd(*valobj_sp) { } @@ -808,7 +803,7 @@ lldb_private::formatters::NSDataSummaryProvider (ValueObject& valobj, Stream& st ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; bool is_64bit = (process_sp->GetAddressByteSize() == 8); @@ -834,11 +829,20 @@ lldb_private::formatters::NSDataSummaryProvider (ValueObject& valobj, Stream& st if (error.Fail()) return false; } - else + else if (!strcmp(class_name, "_NSInlineData")) { - if (!ExtractValueFromObjCExpression(valobj, "int", "length", value)) + uint32_t offset = (is_64bit ? 8 : 4); + Error error; + value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + offset, 2, 0, error); + if (error.Fail()) return false; } + else if (!strcmp(class_name, "_NSZeroData")) + { + value = 0; + } + else + return false; stream.Printf("%s%" PRIu64 " byte%s%s", (needs_at ? "@\"" : ""), @@ -869,13 +873,19 @@ lldb_private::formatters::ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& if (!real_guy_sp) return false; } - uint64_t value = real_guy_sp->GetValueAsUnsigned(0); - if (value == 0) + uint8_t value = (real_guy_sp->GetValueAsUnsigned(0) & 0xFF); + switch (value) { - stream.Printf("NO"); - return true; + case 0: + stream.Printf("NO"); + break; + case 1: + stream.Printf("YES"); + break; + default: + stream.Printf("%u",value); + break; } - stream.Printf("YES"); return true; } @@ -932,28 +942,16 @@ lldb_private::formatters::GetOSXEpoch () tm_epoch.tm_min = 0; tm_epoch.tm_mon = 0; tm_epoch.tm_mday = 1; - tm_epoch.tm_year = 2001-1900; // for some reason, we need to subtract 1900 from this field. not sure why. + tm_epoch.tm_year = 2001-1900; tm_epoch.tm_isdst = -1; tm_epoch.tm_gmtoff = 0; - tm_epoch.tm_zone = NULL; + tm_epoch.tm_zone = nullptr; epoch = timegm(&tm_epoch); #endif } return epoch; } -bool -lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) -{ - if (const char* description = valobj.GetObjectDescription()) - { - stream.Printf("%s", description); - return true; - } - else - return false; -} - template bool lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&); diff --git a/source/Plugins/Language/ObjC/Cocoa.h b/source/Plugins/Language/ObjC/Cocoa.h index 0caacf3453d4a..f43b1639cb389 100644 --- a/source/Plugins/Language/ObjC/Cocoa.h +++ b/source/Plugins/Language/ObjC/Cocoa.h @@ -13,6 +13,7 @@ #include "lldb/Core/Stream.h" #include "lldb/Core/ValueObject.h" #include "lldb/DataFormatters/TypeSummary.h" +#include "lldb/DataFormatters/TypeSynthetic.h" #include "lldb/Target/ObjCLanguageRuntime.h" namespace lldb_private { @@ -78,9 +79,6 @@ namespace lldb_private { ObjCSELSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&); bool - RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); - - bool NSError_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); bool @@ -91,6 +89,16 @@ namespace lldb_private { SyntheticChildrenFrontEnd* NSExceptionSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp); + + class NSArray_Additionals + { + public: + static std::map<ConstString, CXXFunctionSummaryFormat::Callback>& + GetAdditionalSummaries (); + + static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>& + GetAdditionalSynthetics (); + }; } // namespace formatters } // namespace lldb_private diff --git a/source/Plugins/Language/ObjC/Makefile b/source/Plugins/Language/ObjC/Makefile deleted file mode 100644 index 58c9e58f2bc63..0000000000000 --- a/source/Plugins/Language/ObjC/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -##===- source/Plugins/Language/ObjC ------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LLDB_LEVEL := ../../../.. -LIBRARYNAME := lldbPluginObjCLanguage -BUILD_ARCHIVE = 1 - -include $(LLDB_LEVEL)/Makefile diff --git a/source/Plugins/Language/ObjC/NSArray.cpp b/source/Plugins/Language/ObjC/NSArray.cpp index ccc82ab95ecc7..5de97b6f02578 100644 --- a/source/Plugins/Language/ObjC/NSArray.cpp +++ b/source/Plugins/Language/ObjC/NSArray.cpp @@ -35,6 +35,20 @@ using namespace lldb_private::formatters; namespace lldb_private { namespace formatters { + std::map<ConstString, CXXFunctionSummaryFormat::Callback>& + NSArray_Additionals::GetAdditionalSummaries () + { + static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map; + return g_map; + } + + std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>& + NSArray_Additionals::GetAdditionalSynthetics () + { + static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> g_map; + return g_map; + } + class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd { public: @@ -73,7 +87,6 @@ namespace lldb_private { ExecutionContextRef m_exe_ctx_ref; uint8_t m_ptr_size; CompilerType m_id_type; - std::vector<lldb::ValueObjectSP> m_children; }; class NSArrayMSyntheticFrontEnd_109 : public NSArrayMSyntheticFrontEnd @@ -103,7 +116,7 @@ namespace lldb_private { struct DataDescriptor_32 { uint32_t _used; - uint32_t _priv1 : 2 ; + uint32_t _priv1 : 2; uint32_t _size : 30; uint32_t _priv2 : 2; uint32_t _offset : 30; @@ -114,7 +127,7 @@ namespace lldb_private { struct DataDescriptor_64 { uint64_t _used; - uint64_t _priv1 : 2 ; + uint64_t _priv1 : 2; uint64_t _size : 62; uint64_t _priv2 : 2; uint64_t _offset : 62; @@ -202,7 +215,6 @@ namespace lldb_private { uint64_t m_items; lldb::addr_t m_data_ptr; CompilerType m_id_type; - std::vector<lldb::ValueObjectSP> m_children; }; class NSArray0SyntheticFrontEnd : public SyntheticChildrenFrontEnd @@ -227,14 +239,14 @@ namespace lldb_private { size_t GetIndexOfChildWithName(const ConstString &name) override; }; - - class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd + + class NSArray1SyntheticFrontEnd : public SyntheticChildrenFrontEnd { public: - NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); - - ~NSArrayCodeRunningSyntheticFrontEnd() override = default; - + NSArray1SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSArray1SyntheticFrontEnd() override = default; + size_t CalculateNumChildren() override; @@ -269,7 +281,7 @@ lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& s ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -281,30 +293,40 @@ lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& s uint64_t value = 0; - const char* class_name = descriptor->GetClassName().GetCString(); + ConstString class_name(descriptor->GetClassName()); - if (!class_name || !*class_name) + static const ConstString g_NSArrayI("__NSArrayI"); + static const ConstString g_NSArrayM("__NSArrayM"); + static const ConstString g_NSArray0("__NSArray0"); + static const ConstString g_NSArray1("__NSSingleObjectArrayI"); + static const ConstString g_NSArrayCF("__NSCFArray"); + + if (class_name.IsEmpty()) return false; - if (!strcmp(class_name,"__NSArrayI")) + if (class_name == g_NSArrayI) { Error error; value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); if (error.Fail()) return false; } - else if (!strcmp(class_name,"__NSArrayM")) + else if (class_name == g_NSArrayM) { Error error; value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); if (error.Fail()) return false; } - else if (!strcmp(class_name,"__NSArray0")) + else if (class_name == g_NSArray0) { value = 0; } - else if (!strcmp(class_name,"__NSCFArray")) + else if (class_name == g_NSArray1) + { + value = 1; + } + else if (class_name == g_NSArrayCF) { Error error; value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + 2 * ptr_size, ptr_size, 0, error); @@ -313,7 +335,11 @@ lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& s } else { - if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) + auto& map(NSArray_Additionals::GetAdditionalSummaries()); + auto iter = map.find(class_name), end = map.end(); + if (iter != end) + return iter->second(valobj, stream, options); + else return false; } @@ -340,8 +366,7 @@ lldb_private::formatters::NSArrayMSyntheticFrontEnd::NSArrayMSyntheticFrontEnd ( SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8), -m_id_type(), -m_children() +m_id_type() { if (valobj_sp) { @@ -354,16 +379,16 @@ m_children() } lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp) : -NSArrayMSyntheticFrontEnd(valobj_sp), -m_data_32(NULL), -m_data_64(NULL) + NSArrayMSyntheticFrontEnd(valobj_sp), + m_data_32(nullptr), + m_data_64(nullptr) { } lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp) : -NSArrayMSyntheticFrontEnd(valobj_sp), -m_data_32(NULL), -m_data_64(NULL) + NSArrayMSyntheticFrontEnd(valobj_sp), + m_data_32(nullptr), + m_data_64(nullptr) { } @@ -386,24 +411,21 @@ lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetChildAtIndex (size_t idx object_at_idx += (pyhs_idx * m_ptr_size); StreamString idx_name; idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); - lldb::ValueObjectSP retval_sp = CreateValueObjectFromAddress(idx_name.GetData(), - object_at_idx, - m_exe_ctx_ref, - m_id_type); - m_children.push_back(retval_sp); - return retval_sp; + return CreateValueObjectFromAddress(idx_name.GetData(), + object_at_idx, + m_exe_ctx_ref, + m_id_type); } bool lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::Update() { - m_children.clear(); ValueObjectSP valobj_sp = m_backend.GetSP(); m_ptr_size = 0; delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; if (!valobj_sp) return false; m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); @@ -432,13 +454,12 @@ lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::Update() bool lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::Update() { - m_children.clear(); ValueObjectSP valobj_sp = m_backend.GetSP(); m_ptr_size = 0; delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; if (!valobj_sp) return false; m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); @@ -483,9 +504,9 @@ lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetIndexOfChildWithName (co lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::~NSArrayMSyntheticFrontEnd_109() { delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; } lldb::addr_t @@ -527,9 +548,9 @@ lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetSize () lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::~NSArrayMSyntheticFrontEnd_1010() { delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; } lldb::addr_t @@ -569,11 +590,11 @@ lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetSize () } lldb_private::formatters::NSArrayISyntheticFrontEnd::NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd (*valobj_sp.get()), -m_exe_ctx_ref (), -m_ptr_size (8), -m_items (0), -m_data_ptr (0) + SyntheticChildrenFrontEnd(*valobj_sp), + m_exe_ctx_ref(), + m_ptr_size(8), + m_items(0), + m_data_ptr(0) { if (valobj_sp) { @@ -609,7 +630,6 @@ lldb_private::formatters::NSArrayISyntheticFrontEnd::Update() m_ptr_size = 0; m_items = 0; m_data_ptr = 0; - m_children.clear(); ValueObjectSP valobj_sp = m_backend.GetSP(); if (!valobj_sp) return false; @@ -649,16 +669,14 @@ lldb_private::formatters::NSArrayISyntheticFrontEnd::GetChildAtIndex (size_t idx return lldb::ValueObjectSP(); StreamString idx_name; idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); - lldb::ValueObjectSP retval_sp = CreateValueObjectFromAddress(idx_name.GetData(), - object_at_idx, - m_exe_ctx_ref, - m_id_type); - m_children.push_back(retval_sp); - return retval_sp; + return CreateValueObjectFromAddress(idx_name.GetData(), + object_at_idx, + m_exe_ctx_ref, + m_id_type); } lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd (*valobj_sp.get()) + SyntheticChildrenFrontEnd(*valobj_sp) { } @@ -692,17 +710,64 @@ lldb_private::formatters::NSArray0SyntheticFrontEnd::GetChildAtIndex (size_t idx return lldb::ValueObjectSP(); } -SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) +lldb_private::formatters::NSArray1SyntheticFrontEnd::NSArray1SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +SyntheticChildrenFrontEnd (*valobj_sp.get()) +{ +} + +size_t +lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + static const ConstString g_zero("[0]"); + + if (name == g_zero) + return 0; + + return UINT32_MAX; +} + +size_t +lldb_private::formatters::NSArray1SyntheticFrontEnd::CalculateNumChildren () +{ + return 1; +} + +bool +lldb_private::formatters::NSArray1SyntheticFrontEnd::Update() +{ + return false; +} + +bool +lldb_private::formatters::NSArray1SyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSArray1SyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + static const ConstString g_zero("[0]"); + + if (idx == 0) + { + CompilerType id_type(m_backend.GetTargetSP()->GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); + return m_backend.GetSyntheticChildAtOffset(m_backend.GetProcessSP()->GetAddressByteSize(), id_type, true, g_zero); + } + return lldb::ValueObjectSP(); +} + +SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCreator (CXXSyntheticChildren* synth, lldb::ValueObjectSP valobj_sp) { if (!valobj_sp) return nullptr; lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); if (!process_sp) - return NULL; + return nullptr; AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(process_sp->GetObjCLanguageRuntime()); if (!runtime) - return NULL; + return nullptr; CompilerType valobj_type(valobj_sp->GetCompilerType()); Flags flags(valobj_type.GetTypeInfo()); @@ -712,28 +777,37 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCre Error error; valobj_sp = valobj_sp->AddressOf(error); if (error.Fail() || !valobj_sp) - return NULL; + return nullptr; } - ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp)); - if (!descriptor.get() || !descriptor->IsValid()) - return NULL; + if (!descriptor || !descriptor->IsValid()) + return nullptr; - const char* class_name = descriptor->GetClassName().GetCString(); + ConstString class_name(descriptor->GetClassName()); - if (!class_name || !*class_name) - return NULL; + static const ConstString g_NSArrayI("__NSArrayI"); + static const ConstString g_NSArrayM("__NSArrayM"); + static const ConstString g_NSArray0("__NSArray0"); + static const ConstString g_NSArray1("__NSSingleObjectArrayI"); + + if (class_name.IsEmpty()) + return nullptr; - if (!strcmp(class_name,"__NSArrayI")) + if (class_name == g_NSArrayI) { return (new NSArrayISyntheticFrontEnd(valobj_sp)); } - else if (!strcmp(class_name,"__NSArray0")) + else if (class_name == g_NSArray0) { return (new NSArray0SyntheticFrontEnd(valobj_sp)); } - else if (!strcmp(class_name,"__NSArrayM")) + else if (class_name == g_NSArray1) + { + return (new NSArray1SyntheticFrontEnd(valobj_sp)); + } + else if (class_name == g_NSArrayM) { if (runtime->GetFoundationVersion() >= 1100) return (new NSArrayMSyntheticFrontEnd_1010(valobj_sp)); @@ -742,51 +816,11 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCre } else { - return (new NSArrayCodeRunningSyntheticFrontEnd(valobj_sp)); - } -} - -lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()) -{} - -size_t -lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::CalculateNumChildren () -{ - uint64_t count = 0; - if (ExtractValueFromObjCExpression(m_backend, "int", "count", count)) - return count; - return 0; -} - -lldb::ValueObjectSP -lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx) -{ - StreamString idx_name; - idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); - lldb::ValueObjectSP valobj_sp = CallSelectorOnObject(m_backend,"id","objectAtIndex:",idx); - if (valobj_sp) - { - valobj_sp->SetPreferredDisplayLanguage(m_backend.GetPreferredDisplayLanguage()); - valobj_sp->SetName(ConstString(idx_name.GetData())); + auto& map(NSArray_Additionals::GetAdditionalSynthetics()); + auto iter = map.find(class_name), end = map.end(); + if (iter != end) + return iter->second(synth, valobj_sp); } - return valobj_sp; -} - -bool -lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::Update() -{ - return false; -} - -bool -lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::MightHaveChildren () -{ - return true; -} - -size_t -lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) -{ - return 0; + + return nullptr; } diff --git a/source/Plugins/Language/ObjC/NSDictionary.cpp b/source/Plugins/Language/ObjC/NSDictionary.cpp index e4a7425329f58..cdebd6b3c23c7 100644 --- a/source/Plugins/Language/ObjC/NSDictionary.cpp +++ b/source/Plugins/Language/ObjC/NSDictionary.cpp @@ -63,7 +63,7 @@ GetLLDBNSPairType (TargetSP target_sp) if (!compiler_type) { - compiler_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC); + compiler_type = target_ast_context->CreateRecordType(nullptr, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC); if (compiler_type) { @@ -131,6 +131,32 @@ namespace lldb_private { CompilerType m_pair_type; std::vector<DictionaryItemDescriptor> m_children; }; + + class NSDictionary1SyntheticFrontEnd : public SyntheticChildrenFrontEnd + { + public: + NSDictionary1SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); + + ~NSDictionary1SyntheticFrontEnd() 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: + ValueObjectSP m_pair; + }; class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd { @@ -190,29 +216,6 @@ namespace lldb_private { CompilerType m_pair_type; std::vector<DictionaryItemDescriptor> m_children; }; - - class NSDictionaryCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd - { - public: - NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); - - ~NSDictionaryCodeRunningSyntheticFrontEnd() override = default; - - size_t - CalculateNumChildren() override; - - lldb::ValueObjectSP - GetChildAtIndex(size_t idx) override; - - bool - Update() override; - - bool - MightHaveChildren() override; - - size_t - GetIndexOfChildWithName(const ConstString &name) override; - }; } // namespace formatters } // namespace lldb_private @@ -232,7 +235,7 @@ lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stre ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -245,13 +248,16 @@ lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stre uint64_t value = 0; - ConstString class_name_cs = descriptor->GetClassName(); - const char* class_name = class_name_cs.GetCString(); + ConstString class_name(descriptor->GetClassName()); + + static const ConstString g_DictionaryI("__NSDictionaryI"); + static const ConstString g_DictionaryM("__NSDictionaryM"); + static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI"); - if (!class_name || !*class_name) + if (class_name.IsEmpty()) return false; - - if (!strcmp(class_name,"__NSDictionaryI")) + + if (class_name == g_DictionaryI) { Error error; value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); @@ -259,7 +265,7 @@ lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stre return false; value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); } - else if (!strcmp(class_name,"__NSDictionaryM")) + else if (class_name == g_DictionaryM) { Error error; value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); @@ -267,6 +273,10 @@ lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stre return false; value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); } + else if (class_name == g_Dictionary1) + { + value = 1; + } /*else if (!strcmp(class_name,"__NSCFDictionary")) { Error error; @@ -279,10 +289,10 @@ lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stre else { auto& map(NSDictionary_Additionals::GetAdditionalSummaries()); - auto iter = map.find(class_name_cs), end = map.end(); + auto iter = map.find(class_name), end = map.end(); if (iter != end) return iter->second(valobj, stream, options); - if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) + else return false; } @@ -309,10 +319,10 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSDictionarySyntheticFrontE { lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); if (!process_sp) - return NULL; + return nullptr; ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); if (!runtime) - return NULL; + return nullptr; CompilerType valobj_type(valobj_sp->GetCompilerType()); Flags flags(valobj_type.GetTypeInfo()); @@ -322,111 +332,63 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSDictionarySyntheticFrontE Error error; valobj_sp = valobj_sp->AddressOf(error); if (error.Fail() || !valobj_sp) - return NULL; + return nullptr; } - ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp)); - if (!descriptor.get() || !descriptor->IsValid()) - return NULL; + if (!descriptor || !descriptor->IsValid()) + return nullptr; - ConstString class_name_cs = descriptor->GetClassName(); - const char* class_name = class_name_cs.GetCString(); + ConstString class_name(descriptor->GetClassName()); - if (!class_name || !*class_name) - return NULL; + static const ConstString g_DictionaryI("__NSDictionaryI"); + static const ConstString g_DictionaryM("__NSDictionaryM"); + static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI"); - if (!strcmp(class_name,"__NSDictionaryI")) + if (class_name.IsEmpty()) + return nullptr; + + if (class_name == g_DictionaryI) { return (new NSDictionaryISyntheticFrontEnd(valobj_sp)); } - else if (!strcmp(class_name,"__NSDictionaryM")) + else if (class_name == g_DictionaryM) { return (new NSDictionaryMSyntheticFrontEnd(valobj_sp)); } + else if (class_name == g_Dictionary1) + { + return (new NSDictionary1SyntheticFrontEnd(valobj_sp)); + } else { auto& map(NSDictionary_Additionals::GetAdditionalSynthetics()); - auto iter = map.find(class_name_cs), end = map.end(); + auto iter = map.find(class_name), end = map.end(); if (iter != end) return iter->second(synth, valobj_sp); - return (new NSDictionaryCodeRunningSyntheticFrontEnd(valobj_sp)); } -} - -lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()) -{} - -size_t -lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::CalculateNumChildren () -{ - uint64_t count = 0; - if (ExtractValueFromObjCExpression(m_backend, "int", "count", count)) - return count; - return 0; -} - -lldb::ValueObjectSP -lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx) -{ - StreamString idx_name; - idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); - StreamString key_fetcher_expr; - key_fetcher_expr.Printf("(id)[(NSArray*)[(id)0x%" PRIx64 " allKeys] objectAtIndex:%" PRIu64 "]", m_backend.GetPointerValue(), (uint64_t)idx); - StreamString value_fetcher_expr; - value_fetcher_expr.Printf("(id)[(id)0x%" PRIx64 " objectForKey:(%s)]",m_backend.GetPointerValue(),key_fetcher_expr.GetData()); - StreamString object_fetcher_expr; - object_fetcher_expr.Printf("struct __lldb_autogen_nspair { id key; id value; } _lldb_valgen_item; _lldb_valgen_item.key = %s; _lldb_valgen_item.value = %s; _lldb_valgen_item;",key_fetcher_expr.GetData(),value_fetcher_expr.GetData()); - lldb::ValueObjectSP child_sp; - EvaluateExpressionOptions options; - options.SetKeepInMemory(true); - options.SetLanguage(lldb::eLanguageTypeObjC_plus_plus); - options.SetResultIsInternal(true); - m_backend.GetTargetSP()->EvaluateExpression(object_fetcher_expr.GetData(), - GetViableFrame(m_backend.GetTargetSP().get()), - child_sp, - options); - if (child_sp) - child_sp->SetName(ConstString(idx_name.GetData())); - return child_sp; -} - -bool -lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::Update() -{ - return false; -} - -bool -lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::MightHaveChildren () -{ - return true; -} - -size_t -lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) -{ - return 0; + + return nullptr; } lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_exe_ctx_ref(), -m_ptr_size(8), -m_order(lldb::eByteOrderInvalid), -m_data_32(NULL), -m_data_64(NULL), -m_pair_type() + SyntheticChildrenFrontEnd(*valobj_sp), + m_exe_ctx_ref(), + m_ptr_size(8), + m_order(lldb::eByteOrderInvalid), + m_data_32(nullptr), + m_data_64(nullptr), + m_pair_type() { } lldb_private::formatters::NSDictionaryISyntheticFrontEnd::~NSDictionaryISyntheticFrontEnd () { delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; } size_t @@ -452,9 +414,9 @@ lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update() { m_children.clear(); delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; m_ptr_size = 0; ValueObjectSP valobj_sp = m_backend.GetSP(); if (!valobj_sp) @@ -575,23 +537,113 @@ lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex (size_ return dict_item.valobj_sp; } -lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : +lldb_private::formatters::NSDictionary1SyntheticFrontEnd::NSDictionary1SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_exe_ctx_ref(), -m_ptr_size(8), -m_order(lldb::eByteOrderInvalid), -m_data_32(NULL), -m_data_64(NULL), -m_pair_type() +m_pair(nullptr) +{ +} + +size_t +lldb_private::formatters::NSDictionary1SyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) +{ + static const ConstString g_zero("[0]"); + + if (name == g_zero) + return 0; + + return UINT32_MAX; +} + +size_t +lldb_private::formatters::NSDictionary1SyntheticFrontEnd::CalculateNumChildren () +{ + return 1; +} + +bool +lldb_private::formatters::NSDictionary1SyntheticFrontEnd::Update() +{ + m_pair.reset(); + return false; +} + +bool +lldb_private::formatters::NSDictionary1SyntheticFrontEnd::MightHaveChildren () +{ + return true; +} + +lldb::ValueObjectSP +lldb_private::formatters::NSDictionary1SyntheticFrontEnd::GetChildAtIndex (size_t idx) +{ + if (idx != 0) + return lldb::ValueObjectSP(); + + if (m_pair.get()) + return m_pair; + + auto process_sp(m_backend.GetProcessSP()); + if (!process_sp) + return nullptr; + + auto ptr_size = process_sp->GetAddressByteSize(); + + lldb::addr_t key_ptr = m_backend.GetValueAsUnsigned(LLDB_INVALID_ADDRESS) + ptr_size; + lldb::addr_t value_ptr = key_ptr + ptr_size; + + Error error; + + lldb::addr_t value_at_idx = process_sp->ReadPointerFromMemory(key_ptr, error); + if (error.Fail()) + return nullptr; + lldb::addr_t key_at_idx = process_sp->ReadPointerFromMemory(value_ptr, error); + if (error.Fail()) + return nullptr; + + auto pair_type = GetLLDBNSPairType(process_sp->GetTarget().shared_from_this()); + + DataBufferSP buffer_sp(new DataBufferHeap(2*ptr_size,0)); + + if (ptr_size == 8) + { + uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes(); + *data_ptr = key_at_idx; + *(data_ptr+1) = value_at_idx; + } + else + { + uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); + *data_ptr = key_ptr; + *(data_ptr+1) = value_ptr; + } + + DataExtractor data(buffer_sp, process_sp->GetByteOrder(), ptr_size); + m_pair = CreateValueObjectFromData("[0]", + data, + m_backend.GetExecutionContextRef(), + pair_type); + + + return m_pair; +} + +lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : + SyntheticChildrenFrontEnd(*valobj_sp), + m_exe_ctx_ref(), + m_ptr_size(8), + m_order(lldb::eByteOrderInvalid), + m_data_32(nullptr), + m_data_64(nullptr), + m_pair_type() { } lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd () { delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; } size_t @@ -619,9 +671,9 @@ lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::Update() ValueObjectSP valobj_sp = m_backend.GetSP(); m_ptr_size = 0; delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; if (!valobj_sp) return false; m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); diff --git a/source/Plugins/Language/ObjC/NSError.cpp b/source/Plugins/Language/ObjC/NSError.cpp index c627cd0319264..4bfb024206d3f 100644 --- a/source/Plugins/Language/ObjC/NSError.cpp +++ b/source/Plugins/Language/ObjC/NSError.cpp @@ -34,27 +34,49 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::formatters; -bool -lldb_private::formatters::NSError_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +static lldb::addr_t +DerefToNSErrorPointer (ValueObject& valobj) { - ProcessSP process_sp(valobj.GetProcessSP()); - if (!process_sp) - return false; - - lldb::addr_t ptr_value = LLDB_INVALID_ADDRESS; - CompilerType valobj_type(valobj.GetCompilerType()); Flags type_flags(valobj_type.GetTypeInfo()); if (type_flags.AllClear(eTypeHasValue)) { if (valobj.IsBaseClass() && valobj.GetParent()) - ptr_value = valobj.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + return valobj.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); } else - ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + { + lldb::addr_t ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); + if (type_flags.AllSet(eTypeIsPointer)) + { + CompilerType pointee_type(valobj_type.GetPointeeType()); + Flags pointee_flags(pointee_type.GetTypeInfo()); + if (pointee_flags.AllSet(eTypeIsPointer)) + { + if (ProcessSP process_sp = valobj.GetProcessSP()) + { + Error error; + ptr_value = process_sp->ReadPointerFromMemory(ptr_value, error); + } + } + } + return ptr_value; + } + + return LLDB_INVALID_ADDRESS; +} +bool +lldb_private::formatters::NSError_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options) +{ + ProcessSP process_sp(valobj.GetProcessSP()); + if (!process_sp) + return false; + + lldb::addr_t ptr_value = DerefToNSErrorPointer(valobj); if (ptr_value == LLDB_INVALID_ADDRESS) return false; + size_t ptr_size = process_sp->GetAddressByteSize(); lldb::addr_t code_location = ptr_value + 2 * ptr_size; lldb::addr_t domain_location = ptr_value + 3 * ptr_size; @@ -135,18 +157,7 @@ public: if (!process_sp) return false; - lldb::addr_t userinfo_location = LLDB_INVALID_ADDRESS; - - CompilerType valobj_type(m_backend.GetCompilerType()); - Flags type_flags(valobj_type.GetTypeInfo()); - if (type_flags.AllClear(eTypeHasValue)) - { - if (m_backend.IsBaseClass() && m_backend.GetParent()) - userinfo_location = m_backend.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); - } - else - userinfo_location = m_backend.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); - + lldb::addr_t userinfo_location = DerefToNSErrorPointer(m_backend); if (userinfo_location == LLDB_INVALID_ADDRESS) return false; @@ -158,10 +169,10 @@ public: if (userinfo == LLDB_INVALID_ADDRESS || error.Fail()) return false; InferiorSizedWord isw(userinfo,*process_sp); - m_child_sp = ValueObject::CreateValueObjectFromData("_userInfo", - isw.GetAsData(process_sp->GetByteOrder()), - m_backend.GetExecutionContextRef(), - process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); + m_child_sp = CreateValueObjectFromData("_userInfo", + isw.GetAsData(process_sp->GetByteOrder()), + m_backend.GetExecutionContextRef(), + process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); return false; } diff --git a/source/Plugins/Language/ObjC/NSException.cpp b/source/Plugins/Language/ObjC/NSException.cpp index e58223a4d461e..f70e7c7356e1d 100644 --- a/source/Plugins/Language/ObjC/NSException.cpp +++ b/source/Plugins/Language/ObjC/NSException.cpp @@ -157,10 +157,10 @@ public: if (userinfo == LLDB_INVALID_ADDRESS || error.Fail()) return false; InferiorSizedWord isw(userinfo,*process_sp); - m_child_sp = ValueObject::CreateValueObjectFromData("userInfo", - isw.GetAsData(process_sp->GetByteOrder()), - m_backend.GetExecutionContextRef(), - process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); + m_child_sp = CreateValueObjectFromData("userInfo", + isw.GetAsData(process_sp->GetByteOrder()), + m_backend.GetExecutionContextRef(), + process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID)); return false; } diff --git a/source/Plugins/Language/ObjC/NSIndexPath.cpp b/source/Plugins/Language/ObjC/NSIndexPath.cpp index 245f6da80c7f1..0c8a54d76df18 100644 --- a/source/Plugins/Language/ObjC/NSIndexPath.cpp +++ b/source/Plugins/Language/ObjC/NSIndexPath.cpp @@ -31,6 +31,8 @@ class NSIndexPathSyntheticFrontEnd : public SyntheticChildrenFrontEnd public: NSIndexPathSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : SyntheticChildrenFrontEnd (*valobj_sp.get()), + m_descriptor_sp(nullptr), + m_impl(), m_ptr_size(0), m_uint_star_type() { @@ -169,9 +171,8 @@ protected: Invalid }; - struct Impl { - Mode m_mode; - + struct Impl + { size_t GetNumIndexes () { @@ -200,48 +201,52 @@ protected: return m_outsourced.GetIndexAtIndex (idx); } } - - struct InlinedIndexes { + + struct InlinedIndexes + { public: - void SetIndexes(uint64_t value, Process& p) - { - m_indexes = value; - _lengthForInlinePayload(p.GetAddressByteSize()); - m_process = &p; - } - - size_t - GetNumIndexes () - { - return m_count; - } - - lldb::ValueObjectSP - GetIndexAtIndex (size_t idx, const CompilerType& desired_type) - { - std::pair<uint64_t, bool> value(_indexAtPositionForInlinePayload(idx)); - if (!value.second) - return nullptr; - - Value v; - if (m_ptr_size == 8) - { - Scalar scalar( (unsigned long long)value.first ); - v = Value(scalar); - } - else - { - Scalar scalar( (unsigned int)value.first ); - v = Value(scalar); - } - - v.SetCompilerType(desired_type); - - StreamString idx_name; - idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + void SetIndexes(uint64_t value, Process& p) + { + m_indexes = value; + _lengthForInlinePayload(p.GetAddressByteSize()); + m_process = &p; + } + + size_t + GetNumIndexes () + { + return m_count; + } + + lldb::ValueObjectSP + GetIndexAtIndex (size_t idx, const CompilerType& desired_type) + { + if (!m_process) + return nullptr; - return ValueObjectConstResult::Create(m_process, v, ConstString(idx_name.GetData())); - } + std::pair<uint64_t, bool> value(_indexAtPositionForInlinePayload(idx)); + if (!value.second) + return nullptr; + + Value v; + if (m_ptr_size == 8) + { + Scalar scalar( (unsigned long long)value.first ); + v = Value(scalar); + } + else + { + Scalar scalar( (unsigned int)value.first ); + v = Value(scalar); + } + + v.SetCompilerType(desired_type); + + StreamString idx_name; + idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); + + return ValueObjectConstResult::Create(m_process, v, ConstString(idx_name.GetData())); + } void Clear () @@ -251,53 +256,60 @@ protected: m_ptr_size = 0; m_process = nullptr; } - + + InlinedIndexes () : + m_indexes(0), + m_count(0), + m_ptr_size(0), + m_process(nullptr) + { + } + private: - uint64_t m_indexes; - size_t m_count; - uint32_t m_ptr_size; - Process *m_process; - - // cfr. Foundation for the details of this code - size_t _lengthForInlinePayload(uint32_t ptr_size) { - m_ptr_size = ptr_size; - if (m_ptr_size == 8) - m_count = ((m_indexes >> 3) & 0x7); - else - m_count = ((m_indexes >> 3) & 0x3); - return m_count; - } - - std::pair<uint64_t, bool> - _indexAtPositionForInlinePayload(size_t pos) - { - if (m_ptr_size == 8) - { - switch (pos) { - case 5: return {((m_indexes >> 51) & 0x1ff),true}; - case 4: return {((m_indexes >> 42) & 0x1ff),true}; - case 3: return {((m_indexes >> 33) & 0x1ff),true}; - case 2: return {((m_indexes >> 24) & 0x1ff),true}; - case 1: return {((m_indexes >> 15) & 0x1ff),true}; - case 0: return {((m_indexes >> 6) & 0x1ff),true}; + uint64_t m_indexes; + size_t m_count; + uint32_t m_ptr_size; + Process *m_process; + + // cfr. Foundation for the details of this code + size_t _lengthForInlinePayload(uint32_t ptr_size) { + m_ptr_size = ptr_size; + if (m_ptr_size == 8) + m_count = ((m_indexes >> 3) & 0x7); + else + m_count = ((m_indexes >> 3) & 0x3); + return m_count; + } + + std::pair<uint64_t, bool> + _indexAtPositionForInlinePayload(size_t pos) + { + if (m_ptr_size == 8) + { + switch (pos) { + case 5: return {((m_indexes >> 51) & 0x1ff),true}; + case 4: return {((m_indexes >> 42) & 0x1ff),true}; + case 3: return {((m_indexes >> 33) & 0x1ff),true}; + case 2: return {((m_indexes >> 24) & 0x1ff),true}; + case 1: return {((m_indexes >> 15) & 0x1ff),true}; + case 0: return {((m_indexes >> 6) & 0x1ff),true}; + } } - } - else - { - switch (pos) { - case 2: return {((m_indexes >> 23) & 0x1ff),true}; - case 1: return {((m_indexes >> 14) & 0x1ff),true}; - case 0: return {((m_indexes >> 5) & 0x1ff),true}; - } - } - return {0,false}; - } - + else + { + switch (pos) { + case 2: return {((m_indexes >> 23) & 0x1ff),true}; + case 1: return {((m_indexes >> 14) & 0x1ff),true}; + case 0: return {((m_indexes >> 5) & 0x1ff),true}; + } + } + return {0,false}; + } + }; - struct OutsourcedIndexes { - ValueObject *m_indexes; - size_t m_count; - + + struct OutsourcedIndexes + { lldb::ValueObjectSP GetIndexAtIndex (size_t idx) { @@ -315,9 +327,19 @@ protected: m_indexes = nullptr; m_count = 0; } + + OutsourcedIndexes () : + m_indexes(nullptr), + m_count(0) + { + } + + ValueObject *m_indexes; + size_t m_count; }; - - union { + + union + { struct InlinedIndexes m_inlined; struct OutsourcedIndexes m_outsourced; }; @@ -329,6 +351,13 @@ protected: m_inlined.Clear(); m_outsourced.Clear(); } + + Impl() : + m_mode(Mode::Invalid) + { + } + + Mode m_mode; } m_impl; uint32_t m_ptr_size; diff --git a/source/Plugins/Language/ObjC/NSSet.cpp b/source/Plugins/Language/ObjC/NSSet.cpp index 93115957e329a..315771045ba66 100644 --- a/source/Plugins/Language/ObjC/NSSet.cpp +++ b/source/Plugins/Language/ObjC/NSSet.cpp @@ -94,33 +94,6 @@ namespace lldb_private { std::vector<SetItemDescriptor> m_children; }; - class NSOrderedSetSyntheticFrontEnd : public SyntheticChildrenFrontEnd - { - public: - NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp); - - ~NSOrderedSetSyntheticFrontEnd() override = default; - - size_t - CalculateNumChildren() override; - - lldb::ValueObjectSP - GetChildAtIndex(size_t idx) override; - - bool - Update() override; - - bool - MightHaveChildren() override; - - size_t - GetIndexOfChildWithName(const ConstString &name) override; - - private: - uint32_t m_count; - std::map<uint32_t,lldb::ValueObjectSP> m_children; - }; - class NSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd { public: @@ -215,7 +188,7 @@ lldb_private::formatters::NSSetSummaryProvider (ValueObject& valobj, Stream& str ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); - if (!descriptor.get() || !descriptor->IsValid()) + if (!descriptor || !descriptor->IsValid()) return false; uint32_t ptr_size = process_sp->GetAddressByteSize(); @@ -277,7 +250,7 @@ lldb_private::formatters::NSSetSummaryProvider (ValueObject& valobj, Stream& str auto iter = map.find(class_name_cs), end = map.end(); if (iter != end) return iter->second(valobj, stream, options); - if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) + else return false; } @@ -304,10 +277,10 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSSetSyntheticFrontEndCreat { lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); if (!process_sp) - return NULL; + return nullptr; ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); if (!runtime) - return NULL; + return nullptr; CompilerType valobj_type(valobj_sp->GetCompilerType()); Flags flags(valobj_type.GetTypeInfo()); @@ -317,19 +290,19 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSSetSyntheticFrontEndCreat Error error; valobj_sp = valobj_sp->AddressOf(error); if (error.Fail() || !valobj_sp) - return NULL; + return nullptr; } - ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); + ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp)); - if (!descriptor.get() || !descriptor->IsValid()) - return NULL; + if (!descriptor || !descriptor->IsValid()) + return nullptr; ConstString class_name_cs = descriptor->GetClassName(); const char* class_name = class_name_cs.GetCString(); if (!class_name || !*class_name) - return NULL; + return nullptr; if (!strcmp(class_name,"__NSSetI")) { @@ -339,26 +312,22 @@ SyntheticChildrenFrontEnd* lldb_private::formatters::NSSetSyntheticFrontEndCreat { return (new NSSetMSyntheticFrontEnd(valobj_sp)); } - else if ((!strcmp(class_name,"__NSOrderedSetI")) || (!strcmp(class_name,"__NSOrderedSetM"))) - { - return new NSOrderedSetSyntheticFrontEnd(valobj_sp); // this runs code - } else { auto& map(NSSet_Additionals::GetAdditionalSynthetics()); auto iter = map.find(class_name_cs), end = map.end(); if (iter != end) return iter->second(synth, valobj_sp); - return /*(new NSSetCodeRunningSyntheticFrontEnd(valobj_sp))*/ NULL; + return nullptr; } } lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_exe_ctx_ref(), -m_ptr_size(8), -m_data_32(NULL), -m_data_64(NULL) + SyntheticChildrenFrontEnd(*valobj_sp), + m_exe_ctx_ref(), + m_ptr_size(8), + m_data_32(nullptr), + m_data_64(nullptr) { if (valobj_sp) Update(); @@ -367,9 +336,9 @@ m_data_64(NULL) lldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd () { delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; } size_t @@ -395,9 +364,9 @@ lldb_private::formatters::NSSetISyntheticFrontEnd::Update() { m_children.clear(); delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; m_ptr_size = 0; ValueObjectSP valobj_sp = m_backend.GetSP(); if (!valobj_sp) @@ -521,11 +490,11 @@ lldb_private::formatters::NSSetISyntheticFrontEnd::GetChildAtIndex (size_t idx) } lldb_private::formatters::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_exe_ctx_ref(), -m_ptr_size(8), -m_data_32(NULL), -m_data_64(NULL) + SyntheticChildrenFrontEnd(*valobj_sp), + m_exe_ctx_ref(), + m_ptr_size(8), + m_data_32(nullptr), + m_data_64(nullptr) { if (valobj_sp) Update (); @@ -534,9 +503,9 @@ m_data_64(NULL) lldb_private::formatters::NSSetMSyntheticFrontEnd::~NSSetMSyntheticFrontEnd () { delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; } size_t @@ -564,9 +533,9 @@ lldb_private::formatters::NSSetMSyntheticFrontEnd::Update() ValueObjectSP valobj_sp = m_backend.GetSP(); m_ptr_size = 0; delete m_data_32; - m_data_32 = NULL; + m_data_32 = nullptr; delete m_data_64; - m_data_64 = NULL; + m_data_64 = nullptr; if (!valobj_sp) return false; if (!valobj_sp) @@ -688,69 +657,6 @@ lldb_private::formatters::NSSetMSyntheticFrontEnd::GetChildAtIndex (size_t idx) return set_item.valobj_sp; } -lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : -SyntheticChildrenFrontEnd(*valobj_sp.get()), -m_count(UINT32_MAX), -m_children() -{} - -size_t -lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::CalculateNumChildren () -{ - if (m_count != UINT32_MAX) - return m_count; - uint64_t count_temp; - if (ExtractValueFromObjCExpression(m_backend,"unsigned int","count",count_temp)) - return (m_count = count_temp); - return (m_count = 0); -} - -lldb::ValueObjectSP -lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::GetChildAtIndex (size_t idx) -{ - auto iter = m_children.find(idx); - if (iter == m_children.end()) - { - lldb::ValueObjectSP retval_sp; - if (idx <= m_count) - { - retval_sp = CallSelectorOnObject(m_backend, "id", "objectAtIndex", idx); - if (retval_sp) - { - StreamString idx_name; - idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); - retval_sp->SetName(ConstString(idx_name.GetData())); - } - m_children[idx] = retval_sp; - } - return retval_sp; - } - else - return iter->second; -} - -bool -lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::Update() -{ - return false; -} - -bool -lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::MightHaveChildren () -{ - return true; -} - -size_t -lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) -{ - const char* item_name = name.GetCString(); - uint32_t idx = ExtractIndexFromString(item_name); - if (idx < UINT32_MAX && idx >= CalculateNumChildren()) - return UINT32_MAX; - return idx; -} - template bool lldb_private::formatters::NSSetSummaryProvider<true> (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); diff --git a/source/Plugins/Language/ObjC/ObjCLanguage.cpp b/source/Plugins/Language/ObjC/ObjCLanguage.cpp index 91a3a0fb42999..0ecbfd35b1a2e 100644 --- a/source/Plugins/Language/ObjC/ObjCLanguage.cpp +++ b/source/Plugins/Language/ObjC/ObjCLanguage.cpp @@ -61,6 +61,7 @@ ObjCLanguage::GetPluginNameStatic() //------------------------------------------------------------------ // PluginInterface protocol //------------------------------------------------------------------ + lldb_private::ConstString ObjCLanguage::GetPluginName() { @@ -76,6 +77,7 @@ ObjCLanguage::GetPluginVersion() //------------------------------------------------------------------ // Static Functions //------------------------------------------------------------------ + Language * ObjCLanguage::CreateInstance (lldb::LanguageType language) { @@ -192,7 +194,7 @@ ObjCLanguage::MethodName::GetClassNameWithCategory () m_class_category.SetCStringWithLength (class_start, space_pos - class_start); // If m_class hasn't been filled in and the class with category doesn't // contain a '(', then we can also fill in the m_class - if (!m_class && strchr (m_class_category.GetCString(), '(') == NULL) + if (!m_class && strchr(m_class_category.GetCString(), '(') == nullptr) { m_class = m_class_category; // No '(' was found in the full name, we can definitively say @@ -451,6 +453,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArray0"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSSingleObjectArrayI"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags); @@ -460,6 +463,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSMutableDictionary"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSCFDictionary"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryI"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSSingleEntryDictionaryI"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryM"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFDictionaryRef"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFMutableDictionaryRef"), appkit_flags); @@ -487,6 +491,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayM"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayI"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArray0"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSSingleObjectArrayI"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSArray"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSMutableArray"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSCFArray"), ScriptedSyntheticChildren::Flags()); @@ -495,6 +500,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryM"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryI"), ScriptedSyntheticChildren::Flags()); + AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSSingleEntryDictionaryI"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSCFDictionary"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSDictionary"), ScriptedSyntheticChildren::Flags()); AddCXXSynthetic(objc_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSMutableDictionary"), ScriptedSyntheticChildren::Flags()); @@ -532,6 +538,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFConstantString"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFString"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSPathStore2"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSTaggedPointerString"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSAttributedStringSummaryProvider, "NSAttributedString summary provider", ConstString("NSAttributedString"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSMutableAttributedString"), appkit_flags); @@ -540,6 +547,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSummary(objc_category_sp, lldb_private::formatters::NSBundleSummaryProvider, "NSBundle summary provider", ConstString("NSBundle"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSData"), appkit_flags); + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("_NSInlineData"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteData"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteMutableData"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSMutableData"), appkit_flags); @@ -551,10 +559,7 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSNotification"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSConcreteNotification"), appkit_flags); - - AddStringSummary(objc_category_sp, "domain: ${var._domain} - code: ${var._code}", ConstString("NSError"), appkit_flags); - AddStringSummary(objc_category_sp,"name:${var.name%S} reason:${var.reason%S}",ConstString("NSException"),appkit_flags); - + AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSNumber"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "CFNumberRef summary provider", ConstString("CFNumberRef"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags); @@ -562,11 +567,6 @@ LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFBoolean"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFNumber"), appkit_flags); - AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSDecimalNumber summary provider", ConstString("NSDecimalNumber"), appkit_flags); - AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSHost summary provider", ConstString("NSHost"), appkit_flags); - AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSTask summary provider", ConstString("NSTask"), appkit_flags); - AddCXXSummary(objc_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSValue summary provider", ConstString("NSValue"), appkit_flags); - AddCXXSummary(objc_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("NSURL"), appkit_flags); AddCXXSummary(objc_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("CFURLRef"), appkit_flags); @@ -732,7 +732,7 @@ ObjCLanguage::GetTypeScavenger () ConstString key_cs(key); if (clang_modules_decl_vendor->FindDecls(key_cs, false, UINT32_MAX, decls) > 0 && - decls.size() > 0) + !decls.empty()) { CompilerType module_type = ClangASTContext::GetTypeForDecl(decls.front()); result = true; diff --git a/source/Plugins/Language/ObjC/ObjCLanguage.h b/source/Plugins/Language/ObjC/ObjCLanguage.h index e30aa18c0443d..b1435d26429a5 100644 --- a/source/Plugins/Language/ObjC/ObjCLanguage.h +++ b/source/Plugins/Language/ObjC/ObjCLanguage.h @@ -12,6 +12,7 @@ // C Includes // C++ Includes +#include <cstring> #include <vector> // Other libraries and framework includes @@ -187,7 +188,7 @@ public: if (!name) return false; - if (strchr(name, ':') == NULL) + if (strchr(name, ':') == nullptr) return true; else if (name[strlen(name) - 1] == ':') return true; diff --git a/source/Plugins/Language/ObjCPlusPlus/Makefile b/source/Plugins/Language/ObjCPlusPlus/Makefile deleted file mode 100644 index 74e1a14bcf4df..0000000000000 --- a/source/Plugins/Language/ObjCPlusPlus/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -##===- source/Plugins/Language/ObjCPlusPlus ----------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LLDB_LEVEL := ../../../.. -LIBRARYNAME := lldbPluginObjCPlusPlusLanguage -BUILD_ARCHIVE = 1 - -include $(LLDB_LEVEL)/Makefile |