1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
//===---------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "LibStdcpp.h"
#include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/ValueObject/ValueObject.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/Support/Error.h"
#include <cstddef>
#include <optional>
using namespace lldb;
namespace lldb_private::formatters {
class LibStdcppSpanSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public:
LibStdcppSpanSyntheticFrontEnd(const lldb::ValueObjectSP &valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp) {
if (valobj_sp)
Update();
}
~LibStdcppSpanSyntheticFrontEnd() override = default;
llvm::Expected<uint32_t> CalculateNumChildren() override {
return m_num_elements;
}
lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override {
if (!m_start)
return {};
uint64_t offset = (static_cast<uint64_t>(idx) * m_element_size);
offset += m_start->GetValueAsUnsigned(0);
const std::string name = llvm::formatv("[{0}]", idx);
return CreateValueObjectFromAddress(
name, offset, m_backend.GetExecutionContextRef(), m_element_type);
}
lldb::ChildCacheState Update() override {
const ValueObjectSP data_ptr = m_backend.GetChildMemberWithName("_M_ptr");
if (!data_ptr)
return lldb::ChildCacheState::eRefetch;
m_element_type = data_ptr->GetCompilerType().GetPointeeType();
// Get element size.
llvm::Expected<uint64_t> size_or_err = m_element_type.GetByteSize(nullptr);
if (!size_or_err) {
LLDB_LOG_ERRORV(GetLog(LLDBLog::DataFormatters), size_or_err.takeError(),
"{0}");
return lldb::ChildCacheState::eReuse;
}
m_element_size = *size_or_err;
if (m_element_size > 0) {
m_start = data_ptr.get();
}
// Get number of elements.
if (const ValueObjectSP size_sp =
m_backend.GetChildAtNamePath({"_M_extent", "_M_extent_value"})) {
m_num_elements = size_sp->GetValueAsUnsigned(0);
} else if (const auto arg =
m_backend.GetCompilerType().GetIntegralTemplateArgument(1)) {
m_num_elements = arg->value.GetAPSInt().getLimitedValue();
}
return lldb::ChildCacheState::eReuse;
}
llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override {
if (!m_start)
return llvm::createStringError(
llvm::formatv("Type has no child named {0}", name.GetStringRef()));
auto optional_idx = formatters::ExtractIndexFromString(name.GetCString());
if (!optional_idx) {
return llvm::createStringError(
llvm::formatv("Type has no child named {0}", name.GetStringRef()));
}
return *optional_idx;
}
private:
ValueObject *m_start = nullptr; ///< First element of span. Held, not owned.
CompilerType m_element_type; ///< Type of span elements.
size_t m_num_elements = 0; ///< Number of elements in span.
uint32_t m_element_size = 0; ///< Size in bytes of each span element.
};
SyntheticChildrenFrontEnd *
LibStdcppSpanSyntheticFrontEndCreator(CXXSyntheticChildren * /*unused*/,
lldb::ValueObjectSP valobj_sp) {
if (!valobj_sp)
return nullptr;
const CompilerType type = valobj_sp->GetCompilerType();
if (!type || type.GetNumTemplateArguments() != 2)
return nullptr;
return new LibStdcppSpanSyntheticFrontEnd(valobj_sp);
}
} // namespace lldb_private::formatters
|
