mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-05-18 20:46:05 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

455 lines
12 KiB
C++
Raw Normal View History

Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===//
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
Move the C++ data formatters to the C++ language plugin llvm-svn: 246873
2015-09-04 21:01:18 +00:00
#include "LibCxx.h"
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
Nuke CXXFormatterFunctions.cpp - split the contents of it across different files, so that things are better organized along the C++/ObjC line This is preparatory work for moving these formatters into language categories llvm-svn: 246827
2015-09-04 00:33:51 +00:00
#include "lldb/DataFormatters/FormattersHelpers.h"
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
#include "lldb/Host/Endian.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::formatters;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
namespace lldb_private {
namespace formatters {
class LibcxxStdMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd
{
public:
LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
~LibcxxStdMapSyntheticFrontEnd() override = default;
size_t
CalculateNumChildren() override;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
lldb::ValueObjectSP
GetChildAtIndex(size_t idx) override;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
bool
Update() override;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
bool
MightHaveChildren() override;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
size_t
GetIndexOfChildWithName(const ConstString &name) override;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
private:
bool
GetDataType();
void
GetValueOffset (const lldb::ValueObjectSP& node);
ValueObject* m_tree;
ValueObject* m_root_node;
ClangASTType is now CompilerType. This is more preparation for multiple different kinds of types from different compilers (clang, Pascal, Go, RenderScript, Swift, etc). llvm-svn: 244689
2015-08-11 22:53:00 +00:00
CompilerType m_element_type;
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
uint32_t m_skip_size;
size_t m_count;
std::map<size_t,lldb::ValueObjectSP> m_children;
};
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
} // namespace formatters
} // namespace lldb_private
Reorganize some of the data formatters code to simplify CXXFormattersFunction.h. Also, add a synthetic child provider for libc++'s version of std::initializer_list<T> llvm-svn: 220421
2014-10-22 20:34:38 +00:00
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
class MapEntry
{
public:
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
MapEntry() = default;
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
explicit MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
explicit MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
ValueObjectSP
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
left () const
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
static ConstString g_left("__left_");
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
if (!m_entry_sp)
return m_entry_sp;
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return m_entry_sp->GetChildMemberWithName(g_left, true);
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
ValueObjectSP
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
right () const
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
static ConstString g_right("__right_");
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
if (!m_entry_sp)
return m_entry_sp;
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return m_entry_sp->GetChildMemberWithName(g_right, true);
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
ValueObjectSP
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
parent () const
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
static ConstString g_parent("__parent_");
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
if (!m_entry_sp)
return m_entry_sp;
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return m_entry_sp->GetChildMemberWithName(g_parent, true);
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
uint64_t
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
value () const
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
if (!m_entry_sp)
return 0;
return m_entry_sp->GetValueAsUnsigned(0);
}
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
bool
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
error () const
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
{
Harden against potential empty nodes in the map llvm-svn: 181045
2013-05-03 19:07:20 +00:00
if (!m_entry_sp)
return true;
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
return m_entry_sp->GetError().Fail();
}
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
bool
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
null() const
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
return (value() == 0);
}
ValueObjectSP
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
GetEntry () const
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
return m_entry_sp;
}
void
SetEntry (ValueObjectSP entry)
{
m_entry_sp = entry;
}
bool
operator == (const MapEntry& rhs) const
{
return (rhs.m_entry_sp.get() == m_entry_sp.get());
}
private:
ValueObjectSP m_entry_sp;
};
class MapIterator
{
public:
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
MapIterator() = default;
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
MapIterator (MapEntry entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
MapIterator (ValueObjectSP entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
MapIterator (const MapIterator& rhs) : m_entry(rhs.m_entry),m_max_depth(rhs.m_max_depth), m_error(false) {}
MapIterator (ValueObject* entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
ValueObjectSP
value ()
{
return m_entry.GetEntry();
}
ValueObjectSP
advance (size_t count)
{
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
ValueObjectSP fail(nullptr);
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
if (m_error)
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return fail;
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
size_t steps = 0;
while (count > 0)
{
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
next();
count--, steps++;
if (m_error ||
m_entry.null() ||
(steps > m_max_depth))
return fail;
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
return m_entry.GetEntry();
}
Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes. Differential Revision: http://reviews.llvm.org/D13876 llvm-svn: 250789
2015-10-20 01:10:59 +00:00
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
protected:
void
next ()
{
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
if (m_entry.null())
return;
MapEntry right(m_entry.right());
if (right.null() == false)
{
m_entry = tree_min(std::move(right));
return;
}
size_t steps = 0;
while (!is_left_child(m_entry))
{
if (m_entry.error())
{
m_error = true;
return;
}
m_entry.SetEntry(m_entry.parent());
steps++;
if (steps > m_max_depth)
{
m_entry = MapEntry();
return;
}
}
m_entry = MapEntry(m_entry.parent());
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
private:
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
MapEntry
tree_min (MapEntry&& x)
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
if (x.null())
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return MapEntry();
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
MapEntry left(x.left());
size_t steps = 0;
while (left.null() == false)
{
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
if (left.error())
{
m_error = true;
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return MapEntry();
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
}
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
x = left;
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
left.SetEntry(x.left());
steps++;
if (steps > m_max_depth)
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return MapEntry();
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
return x;
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
bool
Improve the performance of the libc++ std::map formatter. This is not the full solution to the slowness of this formatter, but it's a 5% improvement in our testcase performance, which I am not going to complain too hard about. llvm-svn: 224373
2014-12-16 21:28:16 +00:00
is_left_child (const MapEntry& x)
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
{
if (x.null())
return false;
MapEntry rhs(x.parent());
rhs.SetEntry(rhs.left());
return x.value() == rhs.value();
}
MapEntry m_entry;
size_t m_max_depth;
<rdar://problem/13749871> Improvements to the std::map data formatter to recognize when invalid memory is being explored and bail out instead of looping for a potentially very long time llvm-svn: 181044
2013-05-03 19:04:35 +00:00
bool m_error;
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
};
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()
{
if (valobj_sp)
Update();
}
size_t
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::CalculateNumChildren ()
{
if (m_count != UINT32_MAX)
return m_count;
if (m_tree == NULL)
return 0;
ValueObjectSP m_item(m_tree->GetChildMemberWithName(ConstString("__pair3_"), true));
if (!m_item)
return 0;
m_item = m_item->GetChildMemberWithName(ConstString("__first_"), true);
if (!m_item)
return 0;
m_count = m_item->GetValueAsUnsigned(0);
return m_count;
}
bool
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType()
{
First step in getting LLDB ready to support multiple different type systems. This is the work done by Ryan Brown from http://reviews.llvm.org/D8712 that makes a TypeSystem class and abstracts types to be able to use a type system. All tests pass on MacOSX and passed on linux the last time this was submitted. llvm-svn: 244679
2015-08-11 21:38:15 +00:00
if (m_element_type.GetOpaqueQualType() && m_element_type.GetTypeSystem())
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
return true;
m_element_type.Clear();
ValueObjectSP deref;
Error error;
deref = m_root_node->Dereference(error);
if (!deref || error.Fail())
return false;
deref = deref->GetChildMemberWithName(ConstString("__value_"), true);
if (!deref)
return false;
Final bit of type system cleanup that abstracts declaration contexts into lldb_private::CompilerDeclContext and renames ClangType to CompilerType in many accessors and functions. Create a new "lldb_private::CompilerDeclContext" class that will replace all direct uses of "clang::DeclContext" when used in compiler agnostic code, yet still allow for conversion to clang::DeclContext subclasses by clang specific code. This completes the abstraction of type parsing by removing all "clang::" references from the SymbolFileDWARF. The new "lldb_private::CompilerDeclContext" class abstracts decl contexts found in compiler type systems so they can be used in internal API calls. The TypeSystem is required to support CompilerDeclContexts with new pure virtual functions that start with "DeclContext" in the member function names. Converted all code that used lldb_private::ClangNamespaceDecl over to use the new CompilerDeclContext class and removed the ClangNamespaceDecl.cpp and ClangNamespaceDecl.h files. Removed direct use of clang APIs from SBType and now use the abstract type systems to correctly explore types. Bulk renames for things that used to return a ClangASTType which is now CompilerType: "Type::GetClangFullType()" to "Type::GetFullCompilerType()" "Type::GetClangLayoutType()" to "Type::GetLayoutCompilerType()" "Type::GetClangForwardType()" to "Type::GetForwardCompilerType()" "Value::GetClangType()" to "Value::GetCompilerType()" "Value::SetClangType (const CompilerType &)" to "Value::SetCompilerType (const CompilerType &)" "ValueObject::GetClangType ()" to "ValueObject::GetCompilerType()" many more renames that are similar. llvm-svn: 245905
2015-08-24 23:46:31 +00:00
m_element_type = deref->GetCompilerType();
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
return true;
}
void
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset (const lldb::ValueObjectSP& node)
{
if (m_skip_size != UINT32_MAX)
return;
if (!node)
return;
Final bit of type system cleanup that abstracts declaration contexts into lldb_private::CompilerDeclContext and renames ClangType to CompilerType in many accessors and functions. Create a new "lldb_private::CompilerDeclContext" class that will replace all direct uses of "clang::DeclContext" when used in compiler agnostic code, yet still allow for conversion to clang::DeclContext subclasses by clang specific code. This completes the abstraction of type parsing by removing all "clang::" references from the SymbolFileDWARF. The new "lldb_private::CompilerDeclContext" class abstracts decl contexts found in compiler type systems so they can be used in internal API calls. The TypeSystem is required to support CompilerDeclContexts with new pure virtual functions that start with "DeclContext" in the member function names. Converted all code that used lldb_private::ClangNamespaceDecl over to use the new CompilerDeclContext class and removed the ClangNamespaceDecl.cpp and ClangNamespaceDecl.h files. Removed direct use of clang APIs from SBType and now use the abstract type systems to correctly explore types. Bulk renames for things that used to return a ClangASTType which is now CompilerType: "Type::GetClangFullType()" to "Type::GetFullCompilerType()" "Type::GetClangLayoutType()" to "Type::GetLayoutCompilerType()" "Type::GetClangForwardType()" to "Type::GetForwardCompilerType()" "Value::GetClangType()" to "Value::GetCompilerType()" "Value::SetClangType (const CompilerType &)" to "Value::SetCompilerType (const CompilerType &)" "ValueObject::GetClangType ()" to "ValueObject::GetCompilerType()" many more renames that are similar. llvm-svn: 245905
2015-08-24 23:46:31 +00:00
CompilerType node_type(node->GetCompilerType());
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
uint64_t bit_offset;
Huge change to clean up types. A long time ago we start with clang types that were created by the symbol files and there were many functions in lldb_private::ClangASTContext that helped. Later we create ClangASTType which contains a clang::ASTContext and an opauque QualType, but we didn't switch over to fully using it. There were a lot of places where we would pass around a raw clang_type_t and also pass along a clang::ASTContext separately. This left room for error. This checkin change all type code over to use ClangASTType everywhere and I cleaned up the interfaces quite a bit. Any code that was in ClangASTContext that was type related, was moved over into ClangASTType. All code that used these types was switched over to use all of the new goodness. llvm-svn: 186130
2013-07-11 22:46:58 +00:00
if (node_type.GetIndexOfFieldWithName("__value_", NULL, &bit_offset) == UINT32_MAX)
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
return;
m_skip_size = bit_offset / 8u;
}
lldb::ValueObjectSP
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t idx)
{
Recent builds of libcxx actually wrap an std::map's children values in a union containing either a member named __cc, or either of __cc and __nc (const vs. non-const). This level of wrapping is quite useless for LLDB to show to people, so try to detect it, and filter it out llvm-svn: 217651
2014-09-12 00:55:37 +00:00
static ConstString g___cc("__cc");
static ConstString g___nc("__nc");
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
if (idx >= CalculateNumChildren())
return lldb::ValueObjectSP();
if (m_tree == NULL || m_root_node == NULL)
return lldb::ValueObjectSP();
auto cached = m_children.find(idx);
if (cached != m_children.end())
return cached->second;
bool need_to_skip = (idx > 0);
MapIterator iterator(m_root_node, CalculateNumChildren());
ValueObjectSP iterated_sp(iterator.advance(idx));
if (iterated_sp.get() == NULL)
{
// this tree is garbage - stop
m_tree = NULL; // this will stop all future searches until an Update() happens
return iterated_sp;
}
if (GetDataType())
{
if (!need_to_skip)
{
Error error;
iterated_sp = iterated_sp->Dereference(error);
if (!iterated_sp || error.Fail())
{
m_tree = NULL;
return lldb::ValueObjectSP();
}
GetValueOffset(iterated_sp);
iterated_sp = iterated_sp->GetChildMemberWithName(ConstString("__value_"), true);
if (!iterated_sp)
{
m_tree = NULL;
return lldb::ValueObjectSP();
}
}
else
{
// because of the way our debug info is made, we need to read item 0 first
// so that we can cache information used to generate other elements
if (m_skip_size == UINT32_MAX)
GetChildAtIndex(0);
if (m_skip_size == UINT32_MAX)
{
m_tree = NULL;
return lldb::ValueObjectSP();
}
iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true);
if (!iterated_sp)
{
m_tree = NULL;
return lldb::ValueObjectSP();
}
}
}
else
{
m_tree = NULL;
return lldb::ValueObjectSP();
}
// at this point we have a valid
// we need to copy current_sp into a new object otherwise we will end up with all items named __value_
DataExtractor data;
Better error reporting when a variable can't be read during materialization. First of all, report if we can't read the data for some reason. Second, consult the ValueObject's error and report that if there's some problem. <rdar://problem/16074201> llvm-svn: 202552
2014-02-28 22:27:53 +00:00
Error error;
iterated_sp->GetData(data, error);
if (error.Fail())
{
m_tree = NULL;
return lldb::ValueObjectSP();
}
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
StreamString name;
Fix Windows build using portable types for formatting the log outputs llvm-svn: 202723
2014-03-03 15:39:47 +00:00
name.Printf("[%" PRIu64 "]", (uint64_t)idx);
This patch does a few things: - adds a new flag to mark ValueObjects as "synthetic children generated" - vends new Create functions as part of the SyntheticChildrenFrontEnd that set the flag automatically - moves synthetic child providers over to using these new functions No visible feature change, but preparatory work for feature change llvm-svn: 223819
2014-12-09 19:51:20 +00:00
auto potential_child_sp = CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type);
Recent builds of libcxx actually wrap an std::map's children values in a union containing either a member named __cc, or either of __cc and __nc (const vs. non-const). This level of wrapping is quite useless for LLDB to show to people, so try to detect it, and filter it out llvm-svn: 217651
2014-09-12 00:55:37 +00:00
if (potential_child_sp)
{
switch (potential_child_sp->GetNumChildren())
{
case 1:
{
auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
if (child0_sp && child0_sp->GetName() == g___cc)
potential_child_sp = child0_sp;
break;
}
case 2:
{
auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
auto child1_sp = potential_child_sp->GetChildAtIndex(1, true);
if (child0_sp && child0_sp->GetName() == g___cc &&
child1_sp && child1_sp->GetName() == g___nc)
potential_child_sp = child0_sp;
break;
}
}
potential_child_sp->SetName(ConstString(name.GetData()));
}
return (m_children[idx] = potential_child_sp);
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
}
bool
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update()
{
m_count = UINT32_MAX;
m_tree = m_root_node = NULL;
m_children.clear();
m_tree = m_backend.GetChildMemberWithName(ConstString("__tree_"), true).get();
if (!m_tree)
Fix various build warnings. llvm-svn: 183140
2013-06-03 18:00:07 +00:00
return false;
The formatters for std::shared_ptr, std::weak_ptr, std::list, std::vector and std::map as provided by libc++ are now written in C++ instead of Python std::deque is still in Python but is much less commonly used llvm-svn: 177454
2013-03-19 22:58:48 +00:00
m_root_node = m_tree->GetChildMemberWithName(ConstString("__begin_node_"), true).get();
return false;
}
bool
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::MightHaveChildren ()
{
return true;
}
size_t
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
{
return ExtractIndexFromString(name.GetCString());
}
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
if (!valobj_sp)
return NULL;
return (new LibcxxStdMapSyntheticFrontEnd(valobj_sp));
}
Reference in New Issue Copy Permalink