blob: 329f8286a970e5263066746c8e188ea36528c193 [file] [log] [blame]
Greg Claytonbb1beaa2013-03-26 18:42:13 +00001//===-- LibCxx.cpp ----------------------------------------------*- C++ -*-===//
Enrico Granataea2bc0f2013-02-21 19:57:10 +00002//
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
Enrico Granataea2bc0f2013-02-21 19:57:10 +000010#include "lldb/DataFormatters/CXXFormatterFunctions.h"
Enrico Granatad87cc312015-09-03 01:29:42 +000011#include "lldb/DataFormatters/StringPrinter.h"
12#include "lldb/DataFormatters/TypeSummary.h"
Enrico Granataea2bc0f2013-02-21 19:57:10 +000013
14#include "lldb/Core/DataBufferHeap.h"
Enrico Granata14b74fd2013-05-06 18:55:52 +000015#include "lldb/Core/Debugger.h"
Enrico Granataea2bc0f2013-02-21 19:57:10 +000016#include "lldb/Core/Error.h"
Greg Clayton554f68d2015-02-04 22:00:53 +000017#include "lldb/Core/FormatEntity.h"
Enrico Granataea2bc0f2013-02-21 19:57:10 +000018#include "lldb/Core/Stream.h"
19#include "lldb/Core/ValueObject.h"
20#include "lldb/Core/ValueObjectConstResult.h"
21#include "lldb/Host/Endian.h"
22#include "lldb/Symbol/ClangASTContext.h"
Enrico Granataea2bc0f2013-02-21 19:57:10 +000023#include "lldb/Target/Target.h"
24
25using namespace lldb;
26using namespace lldb_private;
27using namespace lldb_private::formatters;
28
Enrico Granata0dba9b32014-01-08 01:36:59 +000029bool
Enrico Granataf35bc632014-11-06 21:55:30 +000030lldb_private::formatters::LibcxxSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
Enrico Granata0dba9b32014-01-08 01:36:59 +000031{
32 ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
33 if (!valobj_sp)
34 return false;
35 ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true));
36 ValueObjectSP count_sp(valobj_sp->GetChildAtNamePath( {ConstString("__cntrl_"),ConstString("__shared_owners_")} ));
37 ValueObjectSP weakcount_sp(valobj_sp->GetChildAtNamePath( {ConstString("__cntrl_"),ConstString("__shared_weak_owners_")} ));
38
39 if (!ptr_sp)
40 return false;
41
42 if (ptr_sp->GetValueAsUnsigned(0) == 0)
43 {
44 stream.Printf("nullptr");
45 return true;
46 }
47 else
48 {
49 bool print_pointee = false;
50 Error error;
51 ValueObjectSP pointee_sp = ptr_sp->Dereference(error);
52 if (pointee_sp && error.Success())
53 {
54 if (pointee_sp->DumpPrintableRepresentation(stream,
55 ValueObject::eValueObjectRepresentationStyleSummary,
56 lldb::eFormatInvalid,
57 ValueObject::ePrintableRepresentationSpecialCasesDisable,
58 false))
59 print_pointee = true;
60 }
61 if (!print_pointee)
62 stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
63 }
64
65 if (count_sp)
66 stream.Printf(" strong=%" PRIu64, 1+count_sp->GetValueAsUnsigned(0));
67
68 if (weakcount_sp)
69 stream.Printf(" weak=%" PRIu64, 1+weakcount_sp->GetValueAsUnsigned(0));
70
71 return true;
72}
73
Enrico Granataea2bc0f2013-02-21 19:57:10 +000074lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
75SyntheticChildrenFrontEnd(*valobj_sp.get()),
Enrico Granata473316f2013-12-21 08:09:49 +000076m_bool_type(),
Enrico Granataea2bc0f2013-02-21 19:57:10 +000077m_exe_ctx_ref(),
78m_count(0),
79m_base_data_address(0),
Enrico Granata473316f2013-12-21 08:09:49 +000080m_children()
Enrico Granataea2bc0f2013-02-21 19:57:10 +000081{
82 if (valobj_sp)
Enrico Granata473316f2013-12-21 08:09:49 +000083 {
Enrico Granataea2bc0f2013-02-21 19:57:10 +000084 Update();
Greg Clayton99558cc42015-08-24 23:46:31 +000085 m_bool_type = valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool);
Enrico Granata473316f2013-12-21 08:09:49 +000086 }
Enrico Granataea2bc0f2013-02-21 19:57:10 +000087}
88
89size_t
90lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::CalculateNumChildren ()
91{
92 return m_count;
93}
94
95lldb::ValueObjectSP
96lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex (size_t idx)
97{
Enrico Granata473316f2013-12-21 08:09:49 +000098 auto iter = m_children.find(idx),
99 end = m_children.end();
100 if (iter != end)
101 return iter->second;
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000102 if (idx >= m_count)
103 return ValueObjectSP();
104 if (m_base_data_address == 0 || m_count == 0)
105 return ValueObjectSP();
Enrico Granata473316f2013-12-21 08:09:49 +0000106 if (!m_bool_type)
107 return ValueObjectSP();
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000108 size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
109 size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
110 lldb::addr_t byte_location = m_base_data_address + byte_idx;
111 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
112 if (!process_sp)
113 return ValueObjectSP();
114 uint8_t byte = 0;
115 uint8_t mask = 0;
116 Error err;
117 size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
118 if (err.Fail() || bytes_read == 0)
119 return ValueObjectSP();
120 switch (bit_index)
121 {
122 case 0:
123 mask = 1; break;
124 case 1:
125 mask = 2; break;
126 case 2:
127 mask = 4; break;
128 case 3:
129 mask = 8; break;
130 case 4:
131 mask = 16; break;
132 case 5:
133 mask = 32; break;
134 case 6:
135 mask = 64; break;
136 case 7:
137 mask = 128; break;
138 default:
139 return ValueObjectSP();
140 }
141 bool bit_set = ((byte & mask) != 0);
Enrico Granata1cd5e922015-01-28 00:07:51 +0000142 DataBufferSP buffer_sp(new DataBufferHeap(m_bool_type.GetByteSize(nullptr),0));
Enrico Granata473316f2013-12-21 08:09:49 +0000143 if (bit_set && buffer_sp && buffer_sp->GetBytes())
144 *(buffer_sp->GetBytes()) = 1; // regardless of endianness, anything non-zero is true
Deepak Panickal99fbc072014-03-03 15:39:47 +0000145 StreamString name; name.Printf("[%" PRIu64 "]", (uint64_t)idx);
Enrico Granatae29df232014-12-09 19:51:20 +0000146 ValueObjectSP retval_sp(CreateValueObjectFromData(name.GetData(), DataExtractor(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize()), m_exe_ctx_ref, m_bool_type));
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000147 if (retval_sp)
Enrico Granata473316f2013-12-21 08:09:49 +0000148 m_children[idx] = retval_sp;
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000149 return retval_sp;
150}
151
152/*(std::__1::vector<std::__1::allocator<bool> >) vBool = {
153 __begin_ = 0x00000001001000e0
154 __size_ = 56
155 __cap_alloc_ = {
156 std::__1::__libcpp_compressed_pair_imp<unsigned long, std::__1::allocator<unsigned long> > = {
157 __first_ = 1
158 }
159 }
160 }*/
161
162bool
163lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update()
164{
Enrico Granata473316f2013-12-21 08:09:49 +0000165 m_children.clear();
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000166 ValueObjectSP valobj_sp = m_backend.GetSP();
167 if (!valobj_sp)
168 return false;
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000169 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
170 ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName(ConstString("__size_"), true));
171 if (!size_sp)
172 return false;
173 m_count = size_sp->GetValueAsUnsigned(0);
174 if (!m_count)
175 return true;
176 ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName(ConstString("__begin_"), true));
177 if (!begin_sp)
178 {
179 m_count = 0;
180 return false;
181 }
182 m_base_data_address = begin_sp->GetValueAsUnsigned(0);
183 if (!m_base_data_address)
184 {
185 m_count = 0;
186 return false;
187 }
Enrico Granata92373532013-03-19 22:58:48 +0000188 return false;
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000189}
190
191bool
192lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::MightHaveChildren ()
193{
194 return true;
195}
196
197size_t
198lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
199{
200 if (!m_count || !m_base_data_address)
201 return UINT32_MAX;
202 const char* item_name = name.GetCString();
203 uint32_t idx = ExtractIndexFromString(item_name);
204 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
205 return UINT32_MAX;
206 return idx;
207}
208
209lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd ()
210{}
211
212SyntheticChildrenFrontEnd*
213lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
214{
215 if (!valobj_sp)
216 return NULL;
217 return (new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp));
218}
219
220/*
221 (lldb) fr var ibeg --raw --ptr-depth 1
222 (std::__1::__map_iterator<std::__1::__tree_iterator<std::__1::pair<int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::__tree_node<std::__1::pair<int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, void *> *, long> >) ibeg = {
223 __i_ = {
224 __ptr_ = 0x0000000100103870 {
225 std::__1::__tree_node_base<void *> = {
226 std::__1::__tree_end_node<std::__1::__tree_node_base<void *> *> = {
227 __left_ = 0x0000000000000000
228 }
229 __right_ = 0x0000000000000000
230 __parent_ = 0x00000001001038b0
231 __is_black_ = true
232 }
233 __value_ = {
234 first = 0
235 second = { std::string }
236 */
237
238lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
239SyntheticChildrenFrontEnd(*valobj_sp.get()),
240m_pair_ptr()
241{
242 if (valobj_sp)
243 Update();
244}
245
246bool
247lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update()
248{
249 ValueObjectSP valobj_sp = m_backend.GetSP();
250 if (!valobj_sp)
251 return false;
252
253 TargetSP target_sp(valobj_sp->GetTargetSP());
254
255 if (!target_sp)
256 return false;
257
258 if (!valobj_sp)
259 return false;
260
261 // this must be a ValueObject* because it is a child of the ValueObject we are producing children for
262 // it if were a ValueObjectSP, we would end up with a loop (iterator -> synthetic -> child -> parent == iterator)
263 // and that would in turn leak memory by never allowing the ValueObjects to die and free their memory
264 m_pair_ptr = valobj_sp->GetValueForExpressionPath(".__i_.__ptr_->__value_",
265 NULL,
266 NULL,
267 NULL,
Enrico Granata495dccd2015-03-12 22:17:07 +0000268 ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None),
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000269 NULL).get();
270
Enrico Granata92373532013-03-19 22:58:48 +0000271 return false;
Enrico Granataea2bc0f2013-02-21 19:57:10 +0000272}
273
274size_t
275lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::CalculateNumChildren ()
276{
277 return 2;
278}
279
280lldb::ValueObjectSP
281lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx)
282{
283 if (!m_pair_ptr)
284 return lldb::ValueObjectSP();
285 return m_pair_ptr->GetChildAtIndex(idx, true);
286}
287
288bool
289lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::MightHaveChildren ()
290{
291 return true;
292}
293
294size_t
295lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
296{
297 if (name == ConstString("first"))
298 return 0;
299 if (name == ConstString("second"))
300 return 1;
301 return UINT32_MAX;
302}
303
304lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::~LibCxxMapIteratorSyntheticFrontEnd ()
305{
306 // this will be deleted when its parent dies (since it's a child object)
307 //delete m_pair_ptr;
308}
309
310SyntheticChildrenFrontEnd*
311lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
312{
313 if (!valobj_sp)
314 return NULL;
315 return (new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp));
316}
317
318/*
319 (lldb) fr var ibeg --raw --ptr-depth 1 -T
320 (std::__1::__wrap_iter<int *>) ibeg = {
321 (std::__1::__wrap_iter<int *>::iterator_type) __i = 0x00000001001037a0 {
322 (int) *__i = 1
323 }
324 }
325*/
326
327SyntheticChildrenFrontEnd*
328lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
329{
330 static ConstString g_item_name;
331 if (!g_item_name)
332 g_item_name.SetCString("__i");
333 if (!valobj_sp)
334 return NULL;
335 return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name));
336}
Enrico Granata92373532013-03-19 22:58:48 +0000337
338lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
339SyntheticChildrenFrontEnd(*valobj_sp.get()),
340m_cntrl(NULL),
341m_count_sp(),
342m_weak_count_sp(),
343m_ptr_size(0),
344m_byte_order(lldb::eByteOrderInvalid)
345{
346 if (valobj_sp)
347 Update();
348}
349
350size_t
351lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::CalculateNumChildren ()
352{
353 return (m_cntrl ? 1 : 0);
354}
355
356lldb::ValueObjectSP
357lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetChildAtIndex (size_t idx)
358{
359 if (!m_cntrl)
360 return lldb::ValueObjectSP();
361
362 ValueObjectSP valobj_sp = m_backend.GetSP();
363 if (!valobj_sp)
364 return lldb::ValueObjectSP();
365
366 if (idx == 0)
367 return valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true);
368
369 if (idx > 2)
370 return lldb::ValueObjectSP();
371
372 if (idx == 1)
373 {
374 if (!m_count_sp)
375 {
376 ValueObjectSP shared_owners_sp(m_cntrl->GetChildMemberWithName(ConstString("__shared_owners_"),true));
377 if (!shared_owners_sp)
378 return lldb::ValueObjectSP();
379 uint64_t count = 1 + shared_owners_sp->GetValueAsUnsigned(0);
380 DataExtractor data(&count, 8, m_byte_order, m_ptr_size);
Greg Clayton99558cc42015-08-24 23:46:31 +0000381 m_count_sp = CreateValueObjectFromData("count", data, valobj_sp->GetExecutionContextRef(), shared_owners_sp->GetCompilerType());
Enrico Granata92373532013-03-19 22:58:48 +0000382 }
383 return m_count_sp;
384 }
385 else /* if (idx == 2) */
386 {
387 if (!m_weak_count_sp)
388 {
389 ValueObjectSP shared_weak_owners_sp(m_cntrl->GetChildMemberWithName(ConstString("__shared_weak_owners_"),true));
390 if (!shared_weak_owners_sp)
391 return lldb::ValueObjectSP();
392 uint64_t count = 1 + shared_weak_owners_sp->GetValueAsUnsigned(0);
393 DataExtractor data(&count, 8, m_byte_order, m_ptr_size);
Greg Clayton99558cc42015-08-24 23:46:31 +0000394 m_weak_count_sp = CreateValueObjectFromData("count", data, valobj_sp->GetExecutionContextRef(), shared_weak_owners_sp->GetCompilerType());
Enrico Granata92373532013-03-19 22:58:48 +0000395 }
396 return m_weak_count_sp;
397 }
398}
399
400bool
401lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update()
402{
403 m_count_sp.reset();
404 m_weak_count_sp.reset();
405 m_cntrl = NULL;
406
407 ValueObjectSP valobj_sp = m_backend.GetSP();
408 if (!valobj_sp)
409 return false;
410
411 TargetSP target_sp(valobj_sp->GetTargetSP());
412 if (!target_sp)
413 return false;
414
415 m_byte_order = target_sp->GetArchitecture().GetByteOrder();
416 m_ptr_size = target_sp->GetArchitecture().GetAddressByteSize();
417
418 lldb::ValueObjectSP cntrl_sp(valobj_sp->GetChildMemberWithName(ConstString("__cntrl_"),true));
419
420 m_cntrl = cntrl_sp.get(); // need to store the raw pointer to avoid a circular dependency
421 return false;
422}
423
424bool
425lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::MightHaveChildren ()
426{
427 return true;
428}
429
430size_t
431lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
432{
433 if (name == ConstString("__ptr_"))
434 return 0;
435 if (name == ConstString("count"))
436 return 1;
437 if (name == ConstString("weak_count"))
438 return 2;
439 return UINT32_MAX;
440}
441
442lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd ()
443{}
444
445SyntheticChildrenFrontEnd*
446lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
447{
448 if (!valobj_sp)
449 return NULL;
450 return (new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp));
451}
452
Enrico Granata14b74fd2013-05-06 18:55:52 +0000453bool
Enrico Granataf35bc632014-11-06 21:55:30 +0000454lldb_private::formatters::LibcxxContainerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
Enrico Granata14b74fd2013-05-06 18:55:52 +0000455{
456 if (valobj.IsPointerType())
457 {
458 uint64_t value = valobj.GetValueAsUnsigned(0);
459 if (!value)
460 return false;
Matt Kopecef143712013-06-03 18:00:07 +0000461 stream.Printf("0x%016" PRIx64 " ", value);
Enrico Granata14b74fd2013-05-06 18:55:52 +0000462 }
Greg Clayton554f68d2015-02-04 22:00:53 +0000463 return FormatEntity::FormatStringRef("size=${svar%#}", stream, NULL, NULL, NULL, &valobj, false, false);
Enrico Granata14b74fd2013-05-06 18:55:52 +0000464}
Enrico Granatad87cc312015-09-03 01:29:42 +0000465
466// the field layout in a libc++ string (cap, side, data or data, size, cap)
467enum LibcxxStringLayoutMode
468{
469 eLibcxxStringLayoutModeCSD = 0,
470 eLibcxxStringLayoutModeDSC = 1,
471 eLibcxxStringLayoutModeInvalid = 0xffff
472};
473
474// this function abstracts away the layout and mode details of a libc++ string
475// and returns the address of the data and the size ready for callers to consume
476static bool
477ExtractLibcxxStringInfo (ValueObject& valobj,
478 ValueObjectSP &location_sp,
479 uint64_t& size)
480{
481 ValueObjectSP D(valobj.GetChildAtIndexPath({0,0,0,0}));
482 if (!D)
483 return false;
484
485 ValueObjectSP layout_decider(D->GetChildAtIndexPath({0,0}));
486
487 // this child should exist
488 if (!layout_decider)
489 return false;
490
491 ConstString g_data_name("__data_");
492 ConstString g_size_name("__size_");
493 bool short_mode = false; // this means the string is in short-mode and the data is stored inline
494 LibcxxStringLayoutMode layout = (layout_decider->GetName() == g_data_name) ? eLibcxxStringLayoutModeDSC : eLibcxxStringLayoutModeCSD;
495 uint64_t size_mode_value = 0;
496
497 if (layout == eLibcxxStringLayoutModeDSC)
498 {
499 ValueObjectSP size_mode(D->GetChildAtIndexPath({1,1,0}));
500 if (!size_mode)
501 return false;
502
503 if (size_mode->GetName() != g_size_name)
504 {
505 // we are hitting the padding structure, move along
506 size_mode = D->GetChildAtIndexPath({1,1,1});
507 if (!size_mode)
508 return false;
509 }
510
511 size_mode_value = (size_mode->GetValueAsUnsigned(0));
512 short_mode = ((size_mode_value & 0x80) == 0);
513 }
514 else
515 {
516 ValueObjectSP size_mode(D->GetChildAtIndexPath({1,0,0}));
517 if (!size_mode)
518 return false;
519
520 size_mode_value = (size_mode->GetValueAsUnsigned(0));
521 short_mode = ((size_mode_value & 1) == 0);
522 }
523
524 if (short_mode)
525 {
526 ValueObjectSP s(D->GetChildAtIndex(1, true));
527 if (!s)
528 return false;
529 location_sp = s->GetChildAtIndex((layout == eLibcxxStringLayoutModeDSC) ? 0 : 1, true);
530 size = (layout == eLibcxxStringLayoutModeDSC) ? size_mode_value : ((size_mode_value >> 1) % 256);
531 return (location_sp.get() != nullptr);
532 }
533 else
534 {
535 ValueObjectSP l(D->GetChildAtIndex(0, true));
536 if (!l)
537 return false;
538 // we can use the layout_decider object as the data pointer
539 location_sp = (layout == eLibcxxStringLayoutModeDSC) ? layout_decider : l->GetChildAtIndex(2, true);
540 ValueObjectSP size_vo(l->GetChildAtIndex(1, true));
541 if (!size_vo || !location_sp)
542 return false;
543 size = size_vo->GetValueAsUnsigned(0);
544 return true;
545 }
546}
547
548bool
549lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
550{
551 uint64_t size = 0;
552 ValueObjectSP location_sp((ValueObject*)nullptr);
553 if (!ExtractLibcxxStringInfo(valobj, location_sp, size))
554 return false;
555 if (size == 0)
556 {
557 stream.Printf("L\"\"");
558 return true;
559 }
560 if (!location_sp)
561 return false;
562
563 DataExtractor extractor;
564 if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped)
565 size = std::min<decltype(size)>(size, valobj.GetTargetSP()->GetMaximumSizeOfStringSummary());
566 location_sp->GetPointeeData(extractor, 0, size);
567
568 // std::wstring::size() is measured in 'characters', not bytes
569 auto wchar_t_size = valobj.GetTargetSP()->GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeWChar).GetByteSize(nullptr);
570
571 ReadBufferAndDumpToStreamOptions options(valobj);
572 options.SetData(extractor);
573 options.SetStream(&stream);
574 options.SetPrefixToken('L');
575 options.SetQuote('"');
576 options.SetSourceSize(size);
577 options.SetBinaryZeroIsTerminator(false);
578
579 switch (wchar_t_size)
580 {
581 case 1:
582 lldb_private::formatters::ReadBufferAndDumpToStream<lldb_private::formatters::StringElementType::UTF8>(options);
583 break;
584
585 case 2:
586 lldb_private::formatters::ReadBufferAndDumpToStream<lldb_private::formatters::StringElementType::UTF16>(options);
587 break;
588
589 case 4:
590 lldb_private::formatters::ReadBufferAndDumpToStream<lldb_private::formatters::StringElementType::UTF32>(options);
591 break;
592
593 default:
594 stream.Printf("size for wchar_t is not valid");
595 return true;
596 }
597
598 return true;
599}
600
601bool
602lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
603{
604 uint64_t size = 0;
605 ValueObjectSP location_sp((ValueObject*)nullptr);
606
607 if (!ExtractLibcxxStringInfo(valobj, location_sp, size))
608 return false;
609
610 if (size == 0)
611 {
612 stream.Printf("\"\"");
613 return true;
614 }
615
616 if (!location_sp)
617 return false;
618
619 DataExtractor extractor;
620 if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped)
621 size = std::min<decltype(size)>(size, valobj.GetTargetSP()->GetMaximumSizeOfStringSummary());
622 location_sp->GetPointeeData(extractor, 0, size);
623
624 ReadBufferAndDumpToStreamOptions options(valobj);
625 options.SetData(extractor);
626 options.SetStream(&stream);
627 options.SetPrefixToken(0);
628 options.SetQuote('"');
629 options.SetSourceSize(size);
630 options.SetBinaryZeroIsTerminator(false);
631 lldb_private::formatters::ReadBufferAndDumpToStream<lldb_private::formatters::StringElementType::ASCII>(options);
632
633 return true;
634}