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