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   m_element_size = m_element_type.GetByteSize(nullptr);
149 
150   if (m_element_size > 0) {
151     // store raw pointers or end up with a circular dependency
152     m_start =
153         m_backend.GetChildMemberWithName(ConstString("__begin_"), true).get();
154     m_finish =
155         m_backend.GetChildMemberWithName(ConstString("__end_"), true).get();
156   }
157   return false;
158 }
159 
160 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
161     MightHaveChildren() {
162   return true;
163 }
164 
165 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
166     GetIndexOfChildWithName(const ConstString &name) {
167   if (!m_start || !m_finish)
168     return UINT32_MAX;
169   return ExtractIndexFromString(name.GetCString());
170 }
171 
172 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
173     LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
174     : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(),
175       m_count(0), m_base_data_address(0), m_children() {
176   if (valobj_sp) {
177     Update();
178     m_bool_type =
179         valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool);
180   }
181 }
182 
183 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
184     CalculateNumChildren() {
185   return m_count;
186 }
187 
188 lldb::ValueObjectSP
189 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
190     size_t idx) {
191   auto iter = m_children.find(idx), end = m_children.end();
192   if (iter != end)
193     return iter->second;
194   if (idx >= m_count)
195     return ValueObjectSP();
196   if (m_base_data_address == 0 || m_count == 0)
197     return ValueObjectSP();
198   if (!m_bool_type)
199     return ValueObjectSP();
200   size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
201   size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
202   lldb::addr_t byte_location = m_base_data_address + byte_idx;
203   ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
204   if (!process_sp)
205     return ValueObjectSP();
206   uint8_t byte = 0;
207   uint8_t mask = 0;
208   Status err;
209   size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
210   if (err.Fail() || bytes_read == 0)
211     return ValueObjectSP();
212   mask = 1 << bit_index;
213   bool bit_set = ((byte & mask) != 0);
214   DataBufferSP buffer_sp(
215       new DataBufferHeap(m_bool_type.GetByteSize(nullptr), 0));
216   if (bit_set && buffer_sp && buffer_sp->GetBytes()) {
217     // regardless of endianness, anything non-zero is true
218     *(buffer_sp->GetBytes()) = 1;
219   }
220   StreamString name;
221   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
222   ValueObjectSP retval_sp(CreateValueObjectFromData(
223       name.GetString(),
224       DataExtractor(buffer_sp, process_sp->GetByteOrder(),
225                     process_sp->GetAddressByteSize()),
226       m_exe_ctx_ref, m_bool_type));
227   if (retval_sp)
228     m_children[idx] = retval_sp;
229   return retval_sp;
230 }
231 
232 /*(std::__1::vector<std::__1::allocator<bool> >) vBool = {
233  __begin_ = 0x00000001001000e0
234  __size_ = 56
235  __cap_alloc_ = {
236  std::__1::__libcpp_compressed_pair_imp<unsigned long,
237  std::__1::allocator<unsigned long> > = {
238  __first_ = 1
239  }
240  }
241  }*/
242 
243 bool lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() {
244   m_children.clear();
245   ValueObjectSP valobj_sp = m_backend.GetSP();
246   if (!valobj_sp)
247     return false;
248   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
249   ValueObjectSP size_sp(
250       valobj_sp->GetChildMemberWithName(ConstString("__size_"), true));
251   if (!size_sp)
252     return false;
253   m_count = size_sp->GetValueAsUnsigned(0);
254   if (!m_count)
255     return true;
256   ValueObjectSP begin_sp(
257       valobj_sp->GetChildMemberWithName(ConstString("__begin_"), true));
258   if (!begin_sp) {
259     m_count = 0;
260     return false;
261   }
262   m_base_data_address = begin_sp->GetValueAsUnsigned(0);
263   if (!m_base_data_address) {
264     m_count = 0;
265     return false;
266   }
267   return false;
268 }
269 
270 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
271     GetIndexOfChildWithName(const ConstString &name) {
272   if (!m_count || !m_base_data_address)
273     return UINT32_MAX;
274   const char *item_name = name.GetCString();
275   uint32_t idx = ExtractIndexFromString(item_name);
276   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
277     return UINT32_MAX;
278   return idx;
279 }
280 
281 lldb_private::SyntheticChildrenFrontEnd *
282 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator(
283     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
284   if (!valobj_sp)
285     return nullptr;
286   CompilerType type = valobj_sp->GetCompilerType();
287   if (!type.IsValid() || type.GetNumTemplateArguments() == 0)
288     return nullptr;
289   CompilerType arg_type = type.GetTypeTemplateArgument(0);
290   if (arg_type.GetTypeName() == ConstString("bool"))
291     return new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp);
292   return new LibcxxStdVectorSyntheticFrontEnd(valobj_sp);
293 }
294