1 //===-- LibCxxVector.cpp ----------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "LibCxx.h"
11
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/DataFormatters/FormattersHelpers.h"
14 #include "lldb/Utility/ConstString.h"
15
16 using namespace lldb;
17 using namespace lldb_private;
18 using namespace lldb_private::formatters;
19
20 namespace lldb_private {
21 namespace formatters {
22 class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
23 public:
24 LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
25
26 ~LibcxxStdVectorSyntheticFrontEnd() override;
27
28 size_t CalculateNumChildren() override;
29
30 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
31
32 bool Update() override;
33
34 bool MightHaveChildren() override;
35
36 size_t GetIndexOfChildWithName(const ConstString &name) override;
37
38 private:
39 ValueObject *m_start;
40 ValueObject *m_finish;
41 CompilerType m_element_type;
42 uint32_t m_element_size;
43 };
44
45 class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
46 public:
47 LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
48
49 size_t CalculateNumChildren() override;
50
51 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
52
53 bool Update() override;
54
MightHaveChildren()55 bool MightHaveChildren() override { return true; }
56
57 size_t GetIndexOfChildWithName(const ConstString &name) override;
58
59 private:
60 CompilerType m_bool_type;
61 ExecutionContextRef m_exe_ctx_ref;
62 uint64_t m_count;
63 lldb::addr_t m_base_data_address;
64 std::map<size_t, lldb::ValueObjectSP> m_children;
65 };
66
67 } // namespace formatters
68 } // namespace lldb_private
69
70 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)71 LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
72 : SyntheticChildrenFrontEnd(*valobj_sp), m_start(nullptr),
73 m_finish(nullptr), m_element_type(), m_element_size(0) {
74 if (valobj_sp)
75 Update();
76 }
77
78 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
~LibcxxStdVectorSyntheticFrontEnd()79 ~LibcxxStdVectorSyntheticFrontEnd() {
80 // these need to stay around because they are child objects who will follow
81 // their parent's life cycle
82 // delete m_start;
83 // delete m_finish;
84 }
85
86 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
CalculateNumChildren()87 CalculateNumChildren() {
88 if (!m_start || !m_finish)
89 return 0;
90 uint64_t start_val = m_start->GetValueAsUnsigned(0);
91 uint64_t finish_val = m_finish->GetValueAsUnsigned(0);
92
93 if (start_val == 0 || finish_val == 0)
94 return 0;
95
96 if (start_val >= finish_val)
97 return 0;
98
99 size_t num_children = (finish_val - start_val);
100 if (num_children % m_element_size)
101 return 0;
102 return num_children / m_element_size;
103 }
104
105 lldb::ValueObjectSP
GetChildAtIndex(size_t idx)106 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex(
107 size_t idx) {
108 if (!m_start || !m_finish)
109 return lldb::ValueObjectSP();
110
111 uint64_t offset = idx * m_element_size;
112 offset = offset + m_start->GetValueAsUnsigned(0);
113 StreamString name;
114 name.Printf("[%" PRIu64 "]", (uint64_t)idx);
115 return CreateValueObjectFromAddress(name.GetString(), offset,
116 m_backend.GetExecutionContextRef(),
117 m_element_type);
118 }
119
Update()120 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
121 m_start = m_finish = nullptr;
122 ValueObjectSP data_type_finder_sp(
123 m_backend.GetChildMemberWithName(ConstString("__end_cap_"), true));
124 if (!data_type_finder_sp)
125 return false;
126
127 switch (data_type_finder_sp->GetCompilerType().GetNumDirectBaseClasses()) {
128 case 1:
129 // Assume a pre llvm r300140 __compressed_pair implementation:
130 data_type_finder_sp = data_type_finder_sp->GetChildMemberWithName(
131 ConstString("__first_"), true);
132 break;
133 case 2: {
134 // Assume a post llvm r300140 __compressed_pair implementation:
135 ValueObjectSP first_elem_parent_sp =
136 data_type_finder_sp->GetChildAtIndex(0, true);
137 data_type_finder_sp = first_elem_parent_sp->GetChildMemberWithName(
138 ConstString("__value_"), true);
139 break;
140 }
141 default:
142 return false;
143 }
144
145 if (!data_type_finder_sp)
146 return false;
147 m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType();
148 if (llvm::Optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
149 m_element_size = *size;
150
151 if (m_element_size > 0) {
152 // store raw pointers or end up with a circular dependency
153 m_start =
154 m_backend.GetChildMemberWithName(ConstString("__begin_"), true).get();
155 m_finish =
156 m_backend.GetChildMemberWithName(ConstString("__end_"), true).get();
157 }
158 }
159 return false;
160 }
161
162 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
MightHaveChildren()163 MightHaveChildren() {
164 return true;
165 }
166
167 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString & name)168 GetIndexOfChildWithName(const ConstString &name) {
169 if (!m_start || !m_finish)
170 return UINT32_MAX;
171 return ExtractIndexFromString(name.GetCString());
172 }
173
174 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)175 LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
176 : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(),
177 m_count(0), m_base_data_address(0), m_children() {
178 if (valobj_sp) {
179 Update();
180 m_bool_type =
181 valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool);
182 }
183 }
184
185 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
CalculateNumChildren()186 CalculateNumChildren() {
187 return m_count;
188 }
189
190 lldb::ValueObjectSP
GetChildAtIndex(size_t idx)191 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
192 size_t idx) {
193 auto iter = m_children.find(idx), end = m_children.end();
194 if (iter != end)
195 return iter->second;
196 if (idx >= m_count)
197 return {};
198 if (m_base_data_address == 0 || m_count == 0)
199 return {};
200 if (!m_bool_type)
201 return {};
202 size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
203 size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
204 lldb::addr_t byte_location = m_base_data_address + byte_idx;
205 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
206 if (!process_sp)
207 return {};
208 uint8_t byte = 0;
209 uint8_t mask = 0;
210 Status err;
211 size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
212 if (err.Fail() || bytes_read == 0)
213 return {};
214 mask = 1 << bit_index;
215 bool bit_set = ((byte & mask) != 0);
216 llvm::Optional<uint64_t> size = m_bool_type.GetByteSize(nullptr);
217 if (!size)
218 return {};
219 DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
220 if (bit_set && buffer_sp && buffer_sp->GetBytes()) {
221 // regardless of endianness, anything non-zero is true
222 *(buffer_sp->GetBytes()) = 1;
223 }
224 StreamString name;
225 name.Printf("[%" PRIu64 "]", (uint64_t)idx);
226 ValueObjectSP retval_sp(CreateValueObjectFromData(
227 name.GetString(),
228 DataExtractor(buffer_sp, process_sp->GetByteOrder(),
229 process_sp->GetAddressByteSize()),
230 m_exe_ctx_ref, m_bool_type));
231 if (retval_sp)
232 m_children[idx] = retval_sp;
233 return retval_sp;
234 }
235
236 /*(std::__1::vector<std::__1::allocator<bool> >) vBool = {
237 __begin_ = 0x00000001001000e0
238 __size_ = 56
239 __cap_alloc_ = {
240 std::__1::__libcpp_compressed_pair_imp<unsigned long,
241 std::__1::allocator<unsigned long> > = {
242 __first_ = 1
243 }
244 }
245 }*/
246
Update()247 bool lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() {
248 m_children.clear();
249 ValueObjectSP valobj_sp = m_backend.GetSP();
250 if (!valobj_sp)
251 return false;
252 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
253 ValueObjectSP size_sp(
254 valobj_sp->GetChildMemberWithName(ConstString("__size_"), true));
255 if (!size_sp)
256 return false;
257 m_count = size_sp->GetValueAsUnsigned(0);
258 if (!m_count)
259 return true;
260 ValueObjectSP begin_sp(
261 valobj_sp->GetChildMemberWithName(ConstString("__begin_"), true));
262 if (!begin_sp) {
263 m_count = 0;
264 return false;
265 }
266 m_base_data_address = begin_sp->GetValueAsUnsigned(0);
267 if (!m_base_data_address) {
268 m_count = 0;
269 return false;
270 }
271 return false;
272 }
273
274 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString & name)275 GetIndexOfChildWithName(const ConstString &name) {
276 if (!m_count || !m_base_data_address)
277 return UINT32_MAX;
278 const char *item_name = name.GetCString();
279 uint32_t idx = ExtractIndexFromString(item_name);
280 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
281 return UINT32_MAX;
282 return idx;
283 }
284
285 lldb_private::SyntheticChildrenFrontEnd *
LibcxxStdVectorSyntheticFrontEndCreator(CXXSyntheticChildren *,lldb::ValueObjectSP valobj_sp)286 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator(
287 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
288 if (!valobj_sp)
289 return nullptr;
290 CompilerType type = valobj_sp->GetCompilerType();
291 if (!type.IsValid() || type.GetNumTemplateArguments() == 0)
292 return nullptr;
293 CompilerType arg_type = type.GetTypeTemplateArgument(0);
294 if (arg_type.GetTypeName() == ConstString("bool"))
295 return new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp);
296 return new LibcxxStdVectorSyntheticFrontEnd(valobj_sp);
297 }
298