1 //===-- LibStdcpp.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 "LibStdcpp.h"
11 
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/Core/ValueObjectConstResult.h"
14 #include "lldb/DataFormatters/StringPrinter.h"
15 #include "lldb/DataFormatters/VectorIterator.h"
16 #include "lldb/Symbol/ClangASTContext.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Utility/DataBufferHeap.h"
19 #include "lldb/Utility/Endian.h"
20 #include "lldb/Utility/Status.h"
21 #include "lldb/Utility/Stream.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 using namespace lldb_private::formatters;
26 
27 namespace {
28 
29 class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
30   /*
31    (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char,
32    std::char_traits<char>, std::allocator<char> > > >) ibeg = {
33    (_Base_ptr) _M_node = 0x0000000100103910 {
34    (std::_Rb_tree_color) _M_color = _S_black
35    (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0
36    (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000
37    (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000
38    }
39    }
40    */
41 
42 public:
43   explicit LibstdcppMapIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
44 
45   size_t CalculateNumChildren() override;
46 
47   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
48 
49   bool Update() override;
50 
51   bool MightHaveChildren() override;
52 
53   size_t GetIndexOfChildWithName(const ConstString &name) override;
54 
55 private:
56   ExecutionContextRef m_exe_ctx_ref;
57   lldb::addr_t m_pair_address;
58   CompilerType m_pair_type;
59   lldb::ValueObjectSP m_pair_sp;
60 };
61 
62 class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
63 public:
64   explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
65 
66   size_t CalculateNumChildren() override;
67 
68   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
69 
70   bool Update() override;
71 
72   bool MightHaveChildren() override;
73 
74   size_t GetIndexOfChildWithName(const ConstString &name) override;
75 };
76 
77 } // end of anonymous namespace
78 
79 LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd(
80     lldb::ValueObjectSP valobj_sp)
81     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0),
82       m_pair_type(), m_pair_sp() {
83   if (valobj_sp)
84     Update();
85 }
86 
87 bool LibstdcppMapIteratorSyntheticFrontEnd::Update() {
88   ValueObjectSP valobj_sp = m_backend.GetSP();
89   if (!valobj_sp)
90     return false;
91 
92   TargetSP target_sp(valobj_sp->GetTargetSP());
93 
94   if (!target_sp)
95     return false;
96 
97   bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8);
98 
99   if (!valobj_sp)
100     return false;
101   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
102 
103   ValueObjectSP _M_node_sp(
104       valobj_sp->GetChildMemberWithName(ConstString("_M_node"), true));
105   if (!_M_node_sp)
106     return false;
107 
108   m_pair_address = _M_node_sp->GetValueAsUnsigned(0);
109   if (m_pair_address == 0)
110     return false;
111 
112   m_pair_address += (is_64bit ? 32 : 16);
113 
114   CompilerType my_type(valobj_sp->GetCompilerType());
115   if (my_type.GetNumTemplateArguments() >= 1) {
116     CompilerType pair_type = my_type.GetTypeTemplateArgument(0);
117     if (!pair_type)
118       return false;
119     m_pair_type = pair_type;
120   } else
121     return false;
122 
123   return true;
124 }
125 
126 size_t LibstdcppMapIteratorSyntheticFrontEnd::CalculateNumChildren() {
127   return 2;
128 }
129 
130 lldb::ValueObjectSP
131 LibstdcppMapIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
132   if (m_pair_address != 0 && m_pair_type) {
133     if (!m_pair_sp)
134       m_pair_sp = CreateValueObjectFromAddress("pair", m_pair_address,
135                                                m_exe_ctx_ref, m_pair_type);
136     if (m_pair_sp)
137       return m_pair_sp->GetChildAtIndex(idx, true);
138   }
139   return lldb::ValueObjectSP();
140 }
141 
142 bool LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
143 
144 size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
145     const ConstString &name) {
146   if (name == ConstString("first"))
147     return 0;
148   if (name == ConstString("second"))
149     return 1;
150   return UINT32_MAX;
151 }
152 
153 SyntheticChildrenFrontEnd *
154 lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator(
155     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
156   return (valobj_sp ? new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp)
157                     : nullptr);
158 }
159 
160 /*
161  (lldb) fr var ibeg --ptr-depth 1
162  (__gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >)
163  ibeg = {
164  _M_current = 0x00000001001037a0 {
165  *_M_current = 1
166  }
167  }
168  */
169 
170 SyntheticChildrenFrontEnd *
171 lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator(
172     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
173   static ConstString g_item_name;
174   if (!g_item_name)
175     g_item_name.SetCString("_M_current");
176   return (valobj_sp
177               ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name)
178               : nullptr);
179 }
180 
181 lldb_private::formatters::VectorIteratorSyntheticFrontEnd::
182     VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp,
183                                     ConstString item_name)
184     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
185       m_item_name(item_name), m_item_sp() {
186   if (valobj_sp)
187     Update();
188 }
189 
190 bool VectorIteratorSyntheticFrontEnd::Update() {
191   m_item_sp.reset();
192 
193   ValueObjectSP valobj_sp = m_backend.GetSP();
194   if (!valobj_sp)
195     return false;
196 
197   if (!valobj_sp)
198     return false;
199 
200   ValueObjectSP item_ptr(valobj_sp->GetChildMemberWithName(m_item_name, true));
201   if (!item_ptr)
202     return false;
203   if (item_ptr->GetValueAsUnsigned(0) == 0)
204     return false;
205   Status err;
206   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
207   m_item_sp = CreateValueObjectFromAddress(
208       "item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref,
209       item_ptr->GetCompilerType().GetPointeeType());
210   if (err.Fail())
211     m_item_sp.reset();
212   return false;
213 }
214 
215 size_t VectorIteratorSyntheticFrontEnd::CalculateNumChildren() { return 1; }
216 
217 lldb::ValueObjectSP
218 VectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
219   if (idx == 0)
220     return m_item_sp;
221   return lldb::ValueObjectSP();
222 }
223 
224 bool VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
225 
226 size_t VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
227     const ConstString &name) {
228   if (name == ConstString("item"))
229     return 0;
230   return UINT32_MAX;
231 }
232 
233 bool lldb_private::formatters::LibStdcppStringSummaryProvider(
234     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
235   const bool scalar_is_load_addr = true;
236   AddressType addr_type;
237   lldb::addr_t addr_of_string =
238       valobj.GetAddressOf(scalar_is_load_addr, &addr_type);
239   if (addr_of_string != LLDB_INVALID_ADDRESS) {
240     switch (addr_type) {
241     case eAddressTypeLoad: {
242       ProcessSP process_sp(valobj.GetProcessSP());
243       if (!process_sp)
244         return false;
245 
246       StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
247       Status error;
248       lldb::addr_t addr_of_data =
249           process_sp->ReadPointerFromMemory(addr_of_string, error);
250       if (error.Fail() || addr_of_data == 0 ||
251           addr_of_data == LLDB_INVALID_ADDRESS)
252         return false;
253       options.SetLocation(addr_of_data);
254       options.SetProcessSP(process_sp);
255       options.SetStream(&stream);
256       options.SetNeedsZeroTermination(false);
257       options.SetBinaryZeroIsTerminator(true);
258       lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(
259           addr_of_string + process_sp->GetAddressByteSize(), error);
260       if (error.Fail())
261         return false;
262       options.SetSourceSize(size_of_data);
263 
264       if (!StringPrinter::ReadStringAndDumpToStream<
265               StringPrinter::StringElementType::UTF8>(options)) {
266         stream.Printf("Summary Unavailable");
267         return true;
268       } else
269         return true;
270     } break;
271     case eAddressTypeHost:
272       break;
273     case eAddressTypeInvalid:
274     case eAddressTypeFile:
275       break;
276     }
277   }
278   return false;
279 }
280 
281 bool lldb_private::formatters::LibStdcppWStringSummaryProvider(
282     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
283   const bool scalar_is_load_addr = true;
284   AddressType addr_type;
285   lldb::addr_t addr_of_string =
286       valobj.GetAddressOf(scalar_is_load_addr, &addr_type);
287   if (addr_of_string != LLDB_INVALID_ADDRESS) {
288     switch (addr_type) {
289     case eAddressTypeLoad: {
290       ProcessSP process_sp(valobj.GetProcessSP());
291       if (!process_sp)
292         return false;
293 
294       CompilerType wchar_compiler_type =
295           valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
296 
297       if (!wchar_compiler_type)
298         return false;
299 
300       const uint32_t wchar_size = wchar_compiler_type.GetBitSize(
301           nullptr); // Safe to pass NULL for exe_scope here
302 
303       StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
304       Status error;
305       lldb::addr_t addr_of_data =
306           process_sp->ReadPointerFromMemory(addr_of_string, error);
307       if (error.Fail() || addr_of_data == 0 ||
308           addr_of_data == LLDB_INVALID_ADDRESS)
309         return false;
310       options.SetLocation(addr_of_data);
311       options.SetProcessSP(process_sp);
312       options.SetStream(&stream);
313       options.SetNeedsZeroTermination(false);
314       options.SetBinaryZeroIsTerminator(false);
315       lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(
316           addr_of_string + process_sp->GetAddressByteSize(), error);
317       if (error.Fail())
318         return false;
319       options.SetSourceSize(size_of_data);
320       options.SetPrefixToken("L");
321 
322       switch (wchar_size) {
323       case 8:
324         return StringPrinter::ReadStringAndDumpToStream<
325             StringPrinter::StringElementType::UTF8>(options);
326       case 16:
327         return StringPrinter::ReadStringAndDumpToStream<
328             StringPrinter::StringElementType::UTF16>(options);
329       case 32:
330         return StringPrinter::ReadStringAndDumpToStream<
331             StringPrinter::StringElementType::UTF32>(options);
332       default:
333         stream.Printf("size for wchar_t is not valid");
334         return true;
335       }
336       return true;
337     } break;
338     case eAddressTypeHost:
339       break;
340     case eAddressTypeInvalid:
341     case eAddressTypeFile:
342       break;
343     }
344   }
345   return false;
346 }
347 
348 LibStdcppSharedPtrSyntheticFrontEnd::LibStdcppSharedPtrSyntheticFrontEnd(
349     lldb::ValueObjectSP valobj_sp)
350     : SyntheticChildrenFrontEnd(*valobj_sp) {
351   if (valobj_sp)
352     Update();
353 }
354 
355 size_t LibStdcppSharedPtrSyntheticFrontEnd::CalculateNumChildren() { return 1; }
356 
357 lldb::ValueObjectSP
358 LibStdcppSharedPtrSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
359   ValueObjectSP valobj_sp = m_backend.GetSP();
360   if (!valobj_sp)
361     return lldb::ValueObjectSP();
362 
363   if (idx == 0)
364     return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true);
365   else
366     return lldb::ValueObjectSP();
367 }
368 
369 bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; }
370 
371 bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; }
372 
373 size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(
374     const ConstString &name) {
375   if (name == ConstString("_M_ptr"))
376     return 0;
377   return UINT32_MAX;
378 }
379 
380 SyntheticChildrenFrontEnd *
381 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator(
382     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
383   return (valobj_sp ? new LibStdcppSharedPtrSyntheticFrontEnd(valobj_sp)
384                     : nullptr);
385 }
386 
387 bool lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(
388     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
389   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
390   if (!valobj_sp)
391     return false;
392 
393   ValueObjectSP ptr_sp(
394       valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true));
395   if (!ptr_sp)
396     return false;
397 
398   ValueObjectSP usecount_sp(valobj_sp->GetChildAtNamePath(
399       {ConstString("_M_refcount"), ConstString("_M_pi"),
400        ConstString("_M_use_count")}));
401   if (!usecount_sp)
402     return false;
403 
404   if (ptr_sp->GetValueAsUnsigned(0) == 0 ||
405       usecount_sp->GetValueAsUnsigned(0) == 0) {
406     stream.Printf("nullptr");
407     return true;
408   }
409 
410   Status error;
411   ValueObjectSP pointee_sp = ptr_sp->Dereference(error);
412   if (pointee_sp && error.Success()) {
413     if (pointee_sp->DumpPrintableRepresentation(
414             stream, ValueObject::eValueObjectRepresentationStyleSummary,
415             lldb::eFormatInvalid,
416             ValueObject::PrintableRepresentationSpecialCases::eDisable,
417             false)) {
418       return true;
419     }
420   }
421 
422   stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
423   return true;
424 }
425