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 
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::
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::
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::
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
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 
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::
163     MightHaveChildren() {
164   return true;
165 }
166 
167 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
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::
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::
186     CalculateNumChildren() {
187   return m_count;
188 }
189 
190 lldb::ValueObjectSP
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 
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::
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 *
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