1//===-- LibCxxVector.cpp --------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "LibCxx.h"
10
11#include "lldb/DataFormatters/FormattersHelpers.h"
12#include "lldb/Utility/ConstString.h"
13#include "lldb/ValueObject/ValueObject.h"
14#include "lldb/lldb-enumerations.h"
15#include "lldb/lldb-forward.h"
16#include <optional>
17
18using namespace lldb;
19using namespace lldb_private;
20using namespace lldb_private::formatters;
21
22namespace lldb_private {
23namespace formatters {
24class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
25public:
26 LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
27
28 ~LibcxxStdVectorSyntheticFrontEnd() override;
29
30 llvm::Expected<uint32_t> CalculateNumChildren() override;
31
32 lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override;
33
34 lldb::ChildCacheState Update() override;
35
36 llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override;
37
38private:
39 ValueObject *m_start = nullptr;
40 ValueObject *m_finish = nullptr;
41 CompilerType m_element_type;
42 uint32_t m_element_size = 0;
43};
44
45class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
46public:
47 LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
48
49 llvm::Expected<uint32_t> CalculateNumChildren() override;
50
51 lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override;
52
53 lldb::ChildCacheState Update() override;
54
55 llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override;
56
57private:
58 CompilerType m_bool_type;
59 ExecutionContextRef m_exe_ctx_ref;
60 uint64_t m_count = 0;
61 lldb::addr_t m_base_data_address = 0;
62 std::map<size_t, lldb::ValueObjectSP> m_children;
63};
64
65} // namespace formatters
66} // namespace lldb_private
67
68lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
69 LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
70 : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type() {
71 if (valobj_sp)
72 Update();
73}
74
75lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
76 ~LibcxxStdVectorSyntheticFrontEnd() {
77 // these need to stay around because they are child objects who will follow
78 // their parent's life cycle
79 // delete m_start;
80 // delete m_finish;
81}
82
83llvm::Expected<uint32_t> lldb_private::formatters::
84 LibcxxStdVectorSyntheticFrontEnd::CalculateNumChildren() {
85 if (!m_start || !m_finish)
86 return llvm::createStringError(
87 Fmt: "Failed to determine start/end of vector data.");
88
89 uint64_t start_val = m_start->GetValueAsUnsigned(fail_value: 0);
90 uint64_t finish_val = m_finish->GetValueAsUnsigned(fail_value: 0);
91
92 // A default-initialized empty vector.
93 if (start_val == 0 && finish_val == 0)
94 return 0;
95
96 if (start_val == 0)
97 return llvm::createStringError(Fmt: "Invalid value for start of vector.");
98
99 if (finish_val == 0)
100 return llvm::createStringError(Fmt: "Invalid value for end of vector.");
101
102 if (start_val > finish_val)
103 return llvm::createStringError(
104 Fmt: "Start of vector data begins after end pointer.");
105
106 size_t num_children = (finish_val - start_val);
107 if (num_children % m_element_size)
108 return llvm::createStringError(Fmt: "Size not multiple of element size.");
109
110 return num_children / m_element_size;
111}
112
113lldb::ValueObjectSP
114lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex(
115 uint32_t idx) {
116 if (!m_start || !m_finish)
117 return lldb::ValueObjectSP();
118
119 uint64_t offset = idx * m_element_size;
120 offset = offset + m_start->GetValueAsUnsigned(fail_value: 0);
121 StreamString name;
122 name.Printf(format: "[%" PRIu64 "]", (uint64_t)idx);
123 return CreateValueObjectFromAddress(name: name.GetString(), address: offset,
124 exe_ctx: m_backend.GetExecutionContextRef(),
125 type: m_element_type);
126}
127
128static ValueObjectSP GetDataPointer(ValueObject &root) {
129 if (auto cap_sp = root.GetChildMemberWithName(name: "__cap_"))
130 return cap_sp;
131
132 ValueObjectSP cap_sp = root.GetChildMemberWithName(name: "__end_cap_");
133 if (!cap_sp)
134 return nullptr;
135
136 if (!isOldCompressedPairLayout(pair_obj&: *cap_sp))
137 return nullptr;
138
139 return GetFirstValueOfLibCXXCompressedPair(pair&: *cap_sp);
140}
141
142lldb::ChildCacheState
143lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
144 m_start = m_finish = nullptr;
145 ValueObjectSP data_sp(GetDataPointer(root&: m_backend));
146
147 if (!data_sp)
148 return lldb::ChildCacheState::eRefetch;
149
150 m_element_type = data_sp->GetCompilerType().GetPointeeType();
151 llvm::Expected<uint64_t> size_or_err = m_element_type.GetByteSize(exe_scope: nullptr);
152 if (!size_or_err)
153 LLDB_LOG_ERRORV(GetLog(LLDBLog::DataFormatters), size_or_err.takeError(),
154 "{0}");
155 else {
156 m_element_size = *size_or_err;
157
158 if (m_element_size > 0) {
159 // store raw pointers or end up with a circular dependency
160 m_start = m_backend.GetChildMemberWithName(name: "__begin_").get();
161 m_finish = m_backend.GetChildMemberWithName(name: "__end_").get();
162 }
163 }
164 return lldb::ChildCacheState::eRefetch;
165}
166
167llvm::Expected<size_t>
168lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
169 GetIndexOfChildWithName(ConstString name) {
170 if (!m_start || !m_finish)
171 return llvm::createStringError(Fmt: "Type has no child named '%s'",
172 Vals: name.AsCString());
173 auto optional_idx = formatters::ExtractIndexFromString(item_name: name.GetCString());
174 if (!optional_idx) {
175 return llvm::createStringError(Fmt: "Type has no child named '%s'",
176 Vals: name.AsCString());
177 }
178 return *optional_idx;
179}
180
181lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
182 LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
183 : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(),
184 m_children() {
185 if (valobj_sp) {
186 Update();
187 m_bool_type =
188 valobj_sp->GetCompilerType().GetBasicTypeFromAST(basic_type: lldb::eBasicTypeBool);
189 }
190}
191
192llvm::Expected<uint32_t> lldb_private::formatters::
193 LibcxxVectorBoolSyntheticFrontEnd::CalculateNumChildren() {
194 return m_count;
195}
196
197lldb::ValueObjectSP
198lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
199 uint32_t idx) {
200 auto iter = m_children.find(x: idx), end = m_children.end();
201 if (iter != end)
202 return iter->second;
203 if (idx >= m_count)
204 return {};
205 if (m_base_data_address == 0 || m_count == 0)
206 return {};
207 if (!m_bool_type)
208 return {};
209 size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
210 size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
211 lldb::addr_t byte_location = m_base_data_address + byte_idx;
212 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
213 if (!process_sp)
214 return {};
215 uint8_t byte = 0;
216 uint8_t mask = 0;
217 Status err;
218 size_t bytes_read = process_sp->ReadMemory(vm_addr: byte_location, buf: &byte, size: 1, error&: err);
219 if (err.Fail() || bytes_read == 0)
220 return {};
221 mask = 1 << bit_index;
222 bool bit_set = ((byte & mask) != 0);
223 std::optional<uint64_t> size =
224 llvm::expectedToOptional(E: m_bool_type.GetByteSize(exe_scope: nullptr));
225 if (!size)
226 return {};
227 WritableDataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
228 if (bit_set && buffer_sp && buffer_sp->GetBytes()) {
229 // regardless of endianness, anything non-zero is true
230 *(buffer_sp->GetBytes()) = 1;
231 }
232 StreamString name;
233 name.Printf(format: "[%" PRIu64 "]", (uint64_t)idx);
234 ValueObjectSP retval_sp(CreateValueObjectFromData(
235 name: name.GetString(),
236 data: DataExtractor(buffer_sp, process_sp->GetByteOrder(),
237 process_sp->GetAddressByteSize()),
238 exe_ctx: m_exe_ctx_ref, type: m_bool_type));
239 if (retval_sp)
240 m_children[idx] = retval_sp;
241 return retval_sp;
242}
243
244lldb::ChildCacheState
245lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() {
246 m_children.clear();
247 ValueObjectSP valobj_sp = m_backend.GetSP();
248 if (!valobj_sp)
249 return lldb::ChildCacheState::eRefetch;
250 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
251 ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName(name: "__size_"));
252 if (!size_sp)
253 return lldb::ChildCacheState::eRefetch;
254 m_count = size_sp->GetValueAsUnsigned(fail_value: 0);
255 if (!m_count)
256 return lldb::ChildCacheState::eReuse;
257 ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName(name: "__begin_"));
258 if (!begin_sp) {
259 m_count = 0;
260 return lldb::ChildCacheState::eRefetch;
261 }
262 m_base_data_address = begin_sp->GetValueAsUnsigned(fail_value: 0);
263 if (!m_base_data_address) {
264 m_count = 0;
265 return lldb::ChildCacheState::eRefetch;
266 }
267 return lldb::ChildCacheState::eRefetch;
268}
269
270llvm::Expected<size_t>
271lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
272 GetIndexOfChildWithName(ConstString name) {
273 if (!m_count || !m_base_data_address)
274 return llvm::createStringError(Fmt: "Type has no child named '%s'",
275 Vals: name.AsCString());
276 auto optional_idx = ExtractIndexFromString(item_name: name.AsCString());
277 if (!optional_idx) {
278 return llvm::createStringError(Fmt: "Type has no child named '%s'",
279 Vals: name.AsCString());
280 }
281 uint32_t idx = *optional_idx;
282 if (idx >= CalculateNumChildrenIgnoringErrors())
283 return llvm::createStringError(Fmt: "Type has no child named '%s'",
284 Vals: name.AsCString());
285 return idx;
286}
287
288lldb_private::SyntheticChildrenFrontEnd *
289lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator(
290 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
291 if (!valobj_sp)
292 return nullptr;
293 CompilerType type = valobj_sp->GetCompilerType();
294 if (!type.IsValid() || type.GetNumTemplateArguments() == 0)
295 return nullptr;
296 CompilerType arg_type = type.GetTypeTemplateArgument(idx: 0);
297 if (arg_type.GetTypeName() == "bool")
298 return new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp);
299 return new LibcxxStdVectorSyntheticFrontEnd(valobj_sp);
300}
301

source code of lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp