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 // C Includes
11 // C++ Includes
12 // Other libraries and framework includes
13 // Project includes
14 #include "LibCxx.h"
15 
16 #include "lldb/Core/ValueObject.h"
17 #include "lldb/DataFormatters/FormattersHelpers.h"
18 #include "lldb/Utility/ConstString.h"
19 
20 using namespace lldb;
21 using namespace lldb_private;
22 using namespace lldb_private::formatters;
23 
24 namespace lldb_private {
25 namespace formatters {
26 class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
27 public:
28   LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
29 
30   ~LibcxxStdVectorSyntheticFrontEnd() override;
31 
32   size_t CalculateNumChildren() override;
33 
34   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
35 
36   bool Update() override;
37 
38   bool MightHaveChildren() override;
39 
40   size_t GetIndexOfChildWithName(const ConstString &name) override;
41 
42 private:
43   ValueObject *m_start;
44   ValueObject *m_finish;
45   CompilerType m_element_type;
46   uint32_t m_element_size;
47 };
48 
49 class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
50 public:
51   LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
52 
53   size_t CalculateNumChildren() override;
54 
55   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
56 
57   bool Update() override;
58 
59   bool MightHaveChildren() override { return true; }
60 
61   size_t GetIndexOfChildWithName(const ConstString &name) override;
62 
63 private:
64   CompilerType m_bool_type;
65   ExecutionContextRef m_exe_ctx_ref;
66   uint64_t m_count;
67   lldb::addr_t m_base_data_address;
68   std::map<size_t, lldb::ValueObjectSP> m_children;
69 };
70 
71 } // namespace formatters
72 } // namespace lldb_private
73 
74 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
75     LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
76     : SyntheticChildrenFrontEnd(*valobj_sp), m_start(nullptr),
77       m_finish(nullptr), m_element_type(), m_element_size(0) {
78   if (valobj_sp)
79     Update();
80 }
81 
82 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
83     ~LibcxxStdVectorSyntheticFrontEnd() {
84   // these need to stay around because they are child objects who will follow
85   // their parent's life cycle
86   // delete m_start;
87   // delete m_finish;
88 }
89 
90 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
91     CalculateNumChildren() {
92   if (!m_start || !m_finish)
93     return 0;
94   uint64_t start_val = m_start->GetValueAsUnsigned(0);
95   uint64_t finish_val = m_finish->GetValueAsUnsigned(0);
96 
97   if (start_val == 0 || finish_val == 0)
98     return 0;
99 
100   if (start_val >= finish_val)
101     return 0;
102 
103   size_t num_children = (finish_val - start_val);
104   if (num_children % m_element_size)
105     return 0;
106   return num_children / m_element_size;
107 }
108 
109 lldb::ValueObjectSP
110 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex(
111     size_t idx) {
112   if (!m_start || !m_finish)
113     return lldb::ValueObjectSP();
114 
115   uint64_t offset = idx * m_element_size;
116   offset = offset + m_start->GetValueAsUnsigned(0);
117   StreamString name;
118   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
119   return CreateValueObjectFromAddress(name.GetString(), offset,
120                                       m_backend.GetExecutionContextRef(),
121                                       m_element_type);
122 }
123 
124 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
125   m_start = m_finish = nullptr;
126   ValueObjectSP data_type_finder_sp(
127       m_backend.GetChildMemberWithName(ConstString("__end_cap_"), true));
128   if (!data_type_finder_sp)
129     return false;
130 
131   switch (data_type_finder_sp->GetCompilerType().GetNumDirectBaseClasses()) {
132   case 1:
133     // Assume a pre llvm r300140 __compressed_pair implementation:
134     data_type_finder_sp = data_type_finder_sp->GetChildMemberWithName(
135       ConstString("__first_"), true);
136     break;
137   case 2: {
138     // Assume a post llvm r300140 __compressed_pair implementation:
139     ValueObjectSP first_elem_parent_sp =
140       data_type_finder_sp->GetChildAtIndex(0, true);
141     data_type_finder_sp = first_elem_parent_sp->GetChildMemberWithName(
142       ConstString("__value_"), true);
143     break;
144   }
145   default:
146     return false;
147   }
148 
149   if (!data_type_finder_sp)
150     return false;
151   m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType();
152   m_element_size = m_element_type.GetByteSize(nullptr);
153 
154   if (m_element_size > 0) {
155     // store raw pointers or end up with a circular dependency
156     m_start =
157         m_backend.GetChildMemberWithName(ConstString("__begin_"), true).get();
158     m_finish =
159         m_backend.GetChildMemberWithName(ConstString("__end_"), true).get();
160   }
161   return false;
162 }
163 
164 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
165     MightHaveChildren() {
166   return true;
167 }
168 
169 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
170     GetIndexOfChildWithName(const ConstString &name) {
171   if (!m_start || !m_finish)
172     return UINT32_MAX;
173   return ExtractIndexFromString(name.GetCString());
174 }
175 
176 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
177     LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
178     : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(),
179       m_count(0), m_base_data_address(0), m_children() {
180   if (valobj_sp) {
181     Update();
182     m_bool_type =
183         valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool);
184   }
185 }
186 
187 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
188     CalculateNumChildren() {
189   return m_count;
190 }
191 
192 lldb::ValueObjectSP
193 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
194     size_t idx) {
195   auto iter = m_children.find(idx), end = m_children.end();
196   if (iter != end)
197     return iter->second;
198   if (idx >= m_count)
199     return ValueObjectSP();
200   if (m_base_data_address == 0 || m_count == 0)
201     return ValueObjectSP();
202   if (!m_bool_type)
203     return ValueObjectSP();
204   size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
205   size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
206   lldb::addr_t byte_location = m_base_data_address + byte_idx;
207   ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
208   if (!process_sp)
209     return ValueObjectSP();
210   uint8_t byte = 0;
211   uint8_t mask = 0;
212   Status err;
213   size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
214   if (err.Fail() || bytes_read == 0)
215     return ValueObjectSP();
216   mask = 1 << bit_index;
217   bool bit_set = ((byte & mask) != 0);
218   DataBufferSP buffer_sp(
219       new DataBufferHeap(m_bool_type.GetByteSize(nullptr), 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