1 //===-- ValueObjectPrinter.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 "lldb/DataFormatters/ValueObjectPrinter.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/Core/ValueObject.h"
17 #include "lldb/DataFormatters/DataVisualization.h"
18 #include "lldb/Interpreter/CommandInterpreter.h"
19 #include "lldb/Target/Language.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Utility/Stream.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s) {
27   if (valobj) {
28     DumpValueObjectOptions options(*valobj);
29     Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
30   } else {
31     DumpValueObjectOptions options;
32     Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
33   }
34 }
35 
36 ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s,
37                                        const DumpValueObjectOptions &options) {
38   Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
39 }
40 
41 ValueObjectPrinter::ValueObjectPrinter(
42     ValueObject *valobj, Stream *s, const DumpValueObjectOptions &options,
43     const DumpValueObjectOptions::PointerDepth &ptr_depth, uint32_t curr_depth,
44     InstancePointersSetSP printed_instance_pointers) {
45   Init(valobj, s, options, ptr_depth, curr_depth, printed_instance_pointers);
46 }
47 
48 void ValueObjectPrinter::Init(
49     ValueObject *valobj, Stream *s, const DumpValueObjectOptions &options,
50     const DumpValueObjectOptions::PointerDepth &ptr_depth, uint32_t curr_depth,
51     InstancePointersSetSP printed_instance_pointers) {
52   m_orig_valobj = valobj;
53   m_valobj = nullptr;
54   m_stream = s;
55   m_options = options;
56   m_ptr_depth = ptr_depth;
57   m_curr_depth = curr_depth;
58   assert(m_orig_valobj && "cannot print a NULL ValueObject");
59   assert(m_stream && "cannot print to a NULL Stream");
60   m_should_print = eLazyBoolCalculate;
61   m_is_nil = eLazyBoolCalculate;
62   m_is_uninit = eLazyBoolCalculate;
63   m_is_ptr = eLazyBoolCalculate;
64   m_is_ref = eLazyBoolCalculate;
65   m_is_aggregate = eLazyBoolCalculate;
66   m_is_instance_ptr = eLazyBoolCalculate;
67   m_summary_formatter = {nullptr, false};
68   m_value.assign("");
69   m_summary.assign("");
70   m_error.assign("");
71   m_val_summary_ok = false;
72   m_printed_instance_pointers =
73       printed_instance_pointers
74           ? printed_instance_pointers
75           : InstancePointersSetSP(new InstancePointersSet());
76 }
77 
78 bool ValueObjectPrinter::PrintValueObject() {
79   if (!GetMostSpecializedValue() || m_valobj == nullptr)
80     return false;
81 
82   if (ShouldPrintValueObject()) {
83     PrintValidationMarkerIfNeeded();
84 
85     PrintLocationIfNeeded();
86     m_stream->Indent();
87 
88     PrintDecl();
89   }
90 
91   bool value_printed = false;
92   bool summary_printed = false;
93 
94   m_val_summary_ok =
95       PrintValueAndSummaryIfNeeded(value_printed, summary_printed);
96 
97   if (m_val_summary_ok)
98     PrintChildrenIfNeeded(value_printed, summary_printed);
99   else
100     m_stream->EOL();
101 
102   PrintValidationErrorIfNeeded();
103 
104   return true;
105 }
106 
107 bool ValueObjectPrinter::GetMostSpecializedValue() {
108   if (m_valobj)
109     return true;
110   bool update_success = m_orig_valobj->UpdateValueIfNeeded(true);
111   if (!update_success) {
112     m_valobj = m_orig_valobj;
113   } else {
114     if (m_orig_valobj->IsDynamic()) {
115       if (m_options.m_use_dynamic == eNoDynamicValues) {
116         ValueObject *static_value = m_orig_valobj->GetStaticValue().get();
117         if (static_value)
118           m_valobj = static_value;
119         else
120           m_valobj = m_orig_valobj;
121       } else
122         m_valobj = m_orig_valobj;
123     } else {
124       if (m_options.m_use_dynamic != eNoDynamicValues) {
125         ValueObject *dynamic_value =
126             m_orig_valobj->GetDynamicValue(m_options.m_use_dynamic).get();
127         if (dynamic_value)
128           m_valobj = dynamic_value;
129         else
130           m_valobj = m_orig_valobj;
131       } else
132         m_valobj = m_orig_valobj;
133     }
134 
135     if (m_valobj->IsSynthetic()) {
136       if (m_options.m_use_synthetic == false) {
137         ValueObject *non_synthetic = m_valobj->GetNonSyntheticValue().get();
138         if (non_synthetic)
139           m_valobj = non_synthetic;
140       }
141     } else {
142       if (m_options.m_use_synthetic == true) {
143         ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
144         if (synthetic)
145           m_valobj = synthetic;
146       }
147     }
148   }
149   m_compiler_type = m_valobj->GetCompilerType();
150   m_type_flags = m_compiler_type.GetTypeInfo();
151   return true;
152 }
153 
154 const char *ValueObjectPrinter::GetDescriptionForDisplay() {
155   const char *str = m_valobj->GetObjectDescription();
156   if (!str)
157     str = m_valobj->GetSummaryAsCString();
158   if (!str)
159     str = m_valobj->GetValueAsCString();
160   return str;
161 }
162 
163 const char *ValueObjectPrinter::GetRootNameForDisplay(const char *if_fail) {
164   const char *root_valobj_name = m_options.m_root_valobj_name.empty()
165                                      ? m_valobj->GetName().AsCString()
166                                      : m_options.m_root_valobj_name.c_str();
167   return root_valobj_name ? root_valobj_name : if_fail;
168 }
169 
170 bool ValueObjectPrinter::ShouldPrintValueObject() {
171   if (m_should_print == eLazyBoolCalculate)
172     m_should_print =
173         (m_options.m_flat_output == false || m_type_flags.Test(eTypeHasValue))
174             ? eLazyBoolYes
175             : eLazyBoolNo;
176   return m_should_print == eLazyBoolYes;
177 }
178 
179 bool ValueObjectPrinter::IsNil() {
180   if (m_is_nil == eLazyBoolCalculate)
181     m_is_nil = m_valobj->IsNilReference() ? eLazyBoolYes : eLazyBoolNo;
182   return m_is_nil == eLazyBoolYes;
183 }
184 
185 bool ValueObjectPrinter::IsUninitialized() {
186   if (m_is_uninit == eLazyBoolCalculate)
187     m_is_uninit =
188         m_valobj->IsUninitializedReference() ? eLazyBoolYes : eLazyBoolNo;
189   return m_is_uninit == eLazyBoolYes;
190 }
191 
192 bool ValueObjectPrinter::IsPtr() {
193   if (m_is_ptr == eLazyBoolCalculate)
194     m_is_ptr = m_type_flags.Test(eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
195   return m_is_ptr == eLazyBoolYes;
196 }
197 
198 bool ValueObjectPrinter::IsRef() {
199   if (m_is_ref == eLazyBoolCalculate)
200     m_is_ref = m_type_flags.Test(eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
201   return m_is_ref == eLazyBoolYes;
202 }
203 
204 bool ValueObjectPrinter::IsAggregate() {
205   if (m_is_aggregate == eLazyBoolCalculate)
206     m_is_aggregate =
207         m_type_flags.Test(eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
208   return m_is_aggregate == eLazyBoolYes;
209 }
210 
211 bool ValueObjectPrinter::IsInstancePointer() {
212   // you need to do this check on the value's clang type
213   if (m_is_instance_ptr == eLazyBoolCalculate)
214     m_is_instance_ptr = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() &
215                          eTypeInstanceIsPointer) != 0
216                             ? eLazyBoolYes
217                             : eLazyBoolNo;
218   if ((eLazyBoolYes == m_is_instance_ptr) && m_valobj->IsBaseClass())
219     m_is_instance_ptr = eLazyBoolNo;
220   return m_is_instance_ptr == eLazyBoolYes;
221 }
222 
223 bool ValueObjectPrinter::PrintLocationIfNeeded() {
224   if (m_options.m_show_location) {
225     m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
226     return true;
227   }
228   return false;
229 }
230 
231 void ValueObjectPrinter::PrintDecl() {
232   bool show_type = true;
233   // if we are at the root-level and been asked to hide the root's type, then
234   // hide it
235   if (m_curr_depth == 0 && m_options.m_hide_root_type)
236     show_type = false;
237   else
238     // otherwise decide according to the usual rules (asked to show types -
239     // always at the root level)
240     show_type = m_options.m_show_types ||
241                 (m_curr_depth == 0 && !m_options.m_flat_output);
242 
243   StreamString typeName;
244 
245   // always show the type at the root level if it is invalid
246   if (show_type) {
247     // Some ValueObjects don't have types (like registers sets). Only print
248     // the type if there is one to print
249     ConstString type_name;
250     if (m_compiler_type.IsValid()) {
251       if (m_options.m_use_type_display_name)
252         type_name = m_valobj->GetDisplayTypeName();
253       else
254         type_name = m_valobj->GetQualifiedTypeName();
255     } else {
256       // only show an invalid type name if the user explicitly triggered
257       // show_type
258       if (m_options.m_show_types)
259         type_name = ConstString("<invalid type>");
260       else
261         type_name.Clear();
262     }
263 
264     if (type_name) {
265       std::string type_name_str(type_name.GetCString());
266       if (m_options.m_hide_pointer_value) {
267         for (auto iter = type_name_str.find(" *"); iter != std::string::npos;
268              iter = type_name_str.find(" *")) {
269           type_name_str.erase(iter, 2);
270         }
271       }
272       typeName.Printf("%s", type_name_str.c_str());
273     }
274   }
275 
276   StreamString varName;
277 
278   if (m_options.m_flat_output) {
279     // If we are showing types, also qualify the C++ base classes
280     const bool qualify_cxx_base_classes = show_type;
281     if (!m_options.m_hide_name) {
282       m_valobj->GetExpressionPath(varName, qualify_cxx_base_classes);
283     }
284   } else if (!m_options.m_hide_name) {
285     const char *name_cstr = GetRootNameForDisplay("");
286     varName.Printf("%s", name_cstr);
287   }
288 
289   bool decl_printed = false;
290   if (!m_options.m_decl_printing_helper) {
291     // if the user didn't give us a custom helper, pick one based upon the
292     // language, either the one that this printer is bound to, or the preferred
293     // one for the ValueObject
294     lldb::LanguageType lang_type =
295         (m_options.m_varformat_language == lldb::eLanguageTypeUnknown)
296             ? m_valobj->GetPreferredDisplayLanguage()
297             : m_options.m_varformat_language;
298     if (Language *lang_plugin = Language::FindPlugin(lang_type)) {
299       m_options.m_decl_printing_helper = lang_plugin->GetDeclPrintingHelper();
300     }
301   }
302 
303   if (m_options.m_decl_printing_helper) {
304     ConstString type_name_cstr(typeName.GetString());
305     ConstString var_name_cstr(varName.GetString());
306 
307     StreamString dest_stream;
308     if (m_options.m_decl_printing_helper(type_name_cstr, var_name_cstr,
309                                          m_options, dest_stream)) {
310       decl_printed = true;
311       m_stream->PutCString(dest_stream.GetString());
312     }
313   }
314 
315   // if the helper failed, or there is none, do a default thing
316   if (!decl_printed) {
317     if (!typeName.Empty())
318       m_stream->Printf("(%s) ", typeName.GetData());
319     if (!varName.Empty())
320       m_stream->Printf("%s =", varName.GetData());
321     else if (!m_options.m_hide_name)
322       m_stream->Printf(" =");
323   }
324 }
325 
326 bool ValueObjectPrinter::CheckScopeIfNeeded() {
327   if (m_options.m_scope_already_checked)
328     return true;
329   return m_valobj->IsInScope();
330 }
331 
332 TypeSummaryImpl *ValueObjectPrinter::GetSummaryFormatter(bool null_if_omitted) {
333   if (m_summary_formatter.second == false) {
334     TypeSummaryImpl *entry = m_options.m_summary_sp
335                                  ? m_options.m_summary_sp.get()
336                                  : m_valobj->GetSummaryFormat().get();
337 
338     if (m_options.m_omit_summary_depth > 0)
339       entry = NULL;
340     m_summary_formatter.first = entry;
341     m_summary_formatter.second = true;
342   }
343   if (m_options.m_omit_summary_depth > 0 && null_if_omitted)
344     return nullptr;
345   return m_summary_formatter.first;
346 }
347 
348 static bool IsPointerValue(const CompilerType &type) {
349   Flags type_flags(type.GetTypeInfo());
350   if (type_flags.AnySet(eTypeInstanceIsPointer | eTypeIsPointer))
351     return type_flags.AllClear(eTypeIsBuiltIn);
352   return false;
353 }
354 
355 void ValueObjectPrinter::GetValueSummaryError(std::string &value,
356                                               std::string &summary,
357                                               std::string &error) {
358   lldb::Format format = m_options.m_format;
359   // if I am printing synthetized elements, apply the format to those elements
360   // only
361   if (m_options.m_pointer_as_array)
362     m_valobj->GetValueAsCString(lldb::eFormatDefault, value);
363   else if (format != eFormatDefault && format != m_valobj->GetFormat())
364     m_valobj->GetValueAsCString(format, value);
365   else {
366     const char *val_cstr = m_valobj->GetValueAsCString();
367     if (val_cstr)
368       value.assign(val_cstr);
369   }
370   const char *err_cstr = m_valobj->GetError().AsCString();
371   if (err_cstr)
372     error.assign(err_cstr);
373 
374   if (ShouldPrintValueObject()) {
375     if (IsNil())
376       summary.assign("nil");
377     else if (IsUninitialized())
378       summary.assign("<uninitialized>");
379     else if (m_options.m_omit_summary_depth == 0) {
380       TypeSummaryImpl *entry = GetSummaryFormatter();
381       if (entry)
382         m_valobj->GetSummaryAsCString(entry, summary,
383                                       m_options.m_varformat_language);
384       else {
385         const char *sum_cstr =
386             m_valobj->GetSummaryAsCString(m_options.m_varformat_language);
387         if (sum_cstr)
388           summary.assign(sum_cstr);
389       }
390     }
391   }
392 }
393 
394 bool ValueObjectPrinter::PrintValueAndSummaryIfNeeded(bool &value_printed,
395                                                       bool &summary_printed) {
396   bool error_printed = false;
397   if (ShouldPrintValueObject()) {
398     if (!CheckScopeIfNeeded())
399       m_error.assign("out of scope");
400     if (m_error.empty()) {
401       GetValueSummaryError(m_value, m_summary, m_error);
402     }
403     if (m_error.size()) {
404       // we need to support scenarios in which it is actually fine for a value
405       // to have no type
406       // but - on the other hand - if we get an error *AND* have no type, we try
407       // to get out
408       // gracefully, since most often that combination means "could not resolve
409       // a type"
410       // and the default failure mode is quite ugly
411       if (!m_compiler_type.IsValid()) {
412         m_stream->Printf(" <could not resolve type>");
413         return false;
414       }
415 
416       error_printed = true;
417       m_stream->Printf(" <%s>\n", m_error.c_str());
418     } else {
419       // Make sure we have a value and make sure the summary didn't
420       // specify that the value should not be printed - and do not print
421       // the value if this thing is nil
422       // (but show the value if the user passes a format explicitly)
423       TypeSummaryImpl *entry = GetSummaryFormatter();
424       if (!IsNil() && !IsUninitialized() && !m_value.empty() &&
425           (entry == NULL || (entry->DoesPrintValue(m_valobj) ||
426                              m_options.m_format != eFormatDefault) ||
427            m_summary.empty()) &&
428           !m_options.m_hide_value) {
429         if (m_options.m_hide_pointer_value &&
430             IsPointerValue(m_valobj->GetCompilerType())) {
431         } else {
432           m_stream->Printf(" %s", m_value.c_str());
433           value_printed = true;
434         }
435       }
436 
437       if (m_summary.size()) {
438         m_stream->Printf(" %s", m_summary.c_str());
439         summary_printed = true;
440       }
441     }
442   }
443   return !error_printed;
444 }
445 
446 bool ValueObjectPrinter::PrintObjectDescriptionIfNeeded(bool value_printed,
447                                                         bool summary_printed) {
448   if (ShouldPrintValueObject()) {
449     // let's avoid the overly verbose no description error for a nil thing
450     if (m_options.m_use_objc && !IsNil() && !IsUninitialized() &&
451         (!m_options.m_pointer_as_array)) {
452       if (!m_options.m_hide_value || !m_options.m_hide_name)
453         m_stream->Printf(" ");
454       const char *object_desc = nullptr;
455       if (value_printed || summary_printed)
456         object_desc = m_valobj->GetObjectDescription();
457       else
458         object_desc = GetDescriptionForDisplay();
459       if (object_desc && *object_desc) {
460         m_stream->Printf("%s\n", object_desc);
461         return true;
462       } else if (value_printed == false && summary_printed == false)
463         return true;
464       else
465         return false;
466     }
467   }
468   return true;
469 }
470 
471 bool DumpValueObjectOptions::PointerDepth::CanAllowExpansion() const {
472   switch (m_mode) {
473   case Mode::Always:
474   case Mode::Default:
475     return m_count > 0;
476   case Mode::Never:
477     return false;
478   }
479   return false;
480 }
481 
482 bool ValueObjectPrinter::ShouldPrintChildren(
483     bool is_failed_description,
484     DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
485   const bool is_ref = IsRef();
486   const bool is_ptr = IsPtr();
487   const bool is_uninit = IsUninitialized();
488 
489   if (is_uninit)
490     return false;
491 
492   // if the user has specified an element count, always print children
493   // as it is explicit user demand being honored
494   if (m_options.m_pointer_as_array)
495     return true;
496 
497   TypeSummaryImpl *entry = GetSummaryFormatter();
498 
499   if (m_options.m_use_objc)
500     return false;
501 
502   if (is_failed_description || m_curr_depth < m_options.m_max_depth) {
503     // We will show children for all concrete types. We won't show
504     // pointer contents unless a pointer depth has been specified.
505     // We won't reference contents unless the reference is the
506     // root object (depth of zero).
507 
508     // Use a new temporary pointer depth in case we override the
509     // current pointer depth below...
510 
511     if (is_ptr || is_ref) {
512       // We have a pointer or reference whose value is an address.
513       // Make sure that address is not NULL
514       AddressType ptr_address_type;
515       if (m_valobj->GetPointerValue(&ptr_address_type) == 0)
516         return false;
517 
518       const bool is_root_level = m_curr_depth == 0;
519 
520       if (is_ref && is_root_level) {
521         // If this is the root object (depth is zero) that we are showing
522         // and it is a reference, and no pointer depth has been supplied
523         // print out what it references. Don't do this at deeper depths
524         // otherwise we can end up with infinite recursion...
525         return true;
526       }
527 
528       return curr_ptr_depth.CanAllowExpansion();
529     }
530 
531     return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
532   }
533   return false;
534 }
535 
536 bool ValueObjectPrinter::ShouldExpandEmptyAggregates() {
537   TypeSummaryImpl *entry = GetSummaryFormatter();
538 
539   if (!entry)
540     return true;
541 
542   return entry->DoesPrintEmptyAggregates();
543 }
544 
545 ValueObject *ValueObjectPrinter::GetValueObjectForChildrenGeneration() {
546   return m_valobj;
547 }
548 
549 void ValueObjectPrinter::PrintChildrenPreamble() {
550   if (m_options.m_flat_output) {
551     if (ShouldPrintValueObject())
552       m_stream->EOL();
553   } else {
554     if (ShouldPrintValueObject())
555       m_stream->PutCString(IsRef() ? ": {\n" : " {\n");
556     m_stream->IndentMore();
557   }
558 }
559 
560 void ValueObjectPrinter::PrintChild(
561     ValueObjectSP child_sp,
562     const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
563   const uint32_t consumed_depth = (!m_options.m_pointer_as_array) ? 1 : 0;
564   const bool does_consume_ptr_depth =
565       ((IsPtr() && !m_options.m_pointer_as_array) || IsRef());
566 
567   DumpValueObjectOptions child_options(m_options);
568   child_options.SetFormat(m_options.m_format)
569       .SetSummary()
570       .SetRootValueObjectName();
571   child_options.SetScopeChecked(true)
572       .SetHideName(m_options.m_hide_name)
573       .SetHideValue(m_options.m_hide_value)
574       .SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1
575                                ? child_options.m_omit_summary_depth -
576                                      consumed_depth
577                                : 0)
578       .SetElementCount(0);
579 
580   if (child_sp.get()) {
581     ValueObjectPrinter child_printer(
582         child_sp.get(), m_stream, child_options,
583         does_consume_ptr_depth ? --curr_ptr_depth : curr_ptr_depth,
584         m_curr_depth + consumed_depth, m_printed_instance_pointers);
585     child_printer.PrintValueObject();
586   }
587 }
588 
589 uint32_t ValueObjectPrinter::GetMaxNumChildrenToPrint(bool &print_dotdotdot) {
590   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
591 
592   if (m_options.m_pointer_as_array)
593     return m_options.m_pointer_as_array.m_element_count;
594 
595   size_t num_children = synth_m_valobj->GetNumChildren();
596   print_dotdotdot = false;
597   if (num_children) {
598     const size_t max_num_children =
599         m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
600 
601     if (num_children > max_num_children && !m_options.m_ignore_cap) {
602       print_dotdotdot = true;
603       return max_num_children;
604     }
605   }
606   return num_children;
607 }
608 
609 void ValueObjectPrinter::PrintChildrenPostamble(bool print_dotdotdot) {
610   if (!m_options.m_flat_output) {
611     if (print_dotdotdot) {
612       m_valobj->GetTargetSP()
613           ->GetDebugger()
614           .GetCommandInterpreter()
615           .ChildrenTruncated();
616       m_stream->Indent("...\n");
617     }
618     m_stream->IndentLess();
619     m_stream->Indent("}\n");
620   }
621 }
622 
623 bool ValueObjectPrinter::ShouldPrintEmptyBrackets(bool value_printed,
624                                                   bool summary_printed) {
625   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
626 
627   if (!IsAggregate())
628     return false;
629 
630   if (m_options.m_reveal_empty_aggregates == false) {
631     if (value_printed || summary_printed)
632       return false;
633   }
634 
635   if (synth_m_valobj->MightHaveChildren())
636     return true;
637 
638   if (m_val_summary_ok)
639     return false;
640 
641   return true;
642 }
643 
644 static constexpr size_t PhysicalIndexForLogicalIndex(size_t base, size_t stride,
645                                                      size_t logical) {
646   return base + logical * stride;
647 }
648 
649 ValueObjectSP ValueObjectPrinter::GenerateChild(ValueObject *synth_valobj,
650                                                 size_t idx) {
651   if (m_options.m_pointer_as_array) {
652     // if generating pointer-as-array children, use GetSyntheticArrayMember
653     return synth_valobj->GetSyntheticArrayMember(
654         PhysicalIndexForLogicalIndex(
655             m_options.m_pointer_as_array.m_base_element,
656             m_options.m_pointer_as_array.m_stride, idx),
657         true);
658   } else {
659     // otherwise, do the usual thing
660     return synth_valobj->GetChildAtIndex(idx, true);
661   }
662 }
663 
664 void ValueObjectPrinter::PrintChildren(
665     bool value_printed, bool summary_printed,
666     const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
667   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
668 
669   bool print_dotdotdot = false;
670   size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
671   if (num_children) {
672     bool any_children_printed = false;
673 
674     for (size_t idx = 0; idx < num_children; ++idx) {
675       if (ValueObjectSP child_sp = GenerateChild(synth_m_valobj, idx)) {
676         if (!any_children_printed) {
677           PrintChildrenPreamble();
678           any_children_printed = true;
679         }
680         PrintChild(child_sp, curr_ptr_depth);
681       }
682     }
683 
684     if (any_children_printed)
685       PrintChildrenPostamble(print_dotdotdot);
686     else {
687       if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
688         if (ShouldPrintValueObject())
689           m_stream->PutCString(" {}\n");
690         else
691           m_stream->EOL();
692       } else
693         m_stream->EOL();
694     }
695   } else if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
696     // Aggregate, no children...
697     if (ShouldPrintValueObject()) {
698       // if it has a synthetic value, then don't print {}, the synthetic
699       // children are probably only being used to vend a value
700       if (m_valobj->DoesProvideSyntheticValue() ||
701           !ShouldExpandEmptyAggregates())
702         m_stream->PutCString("\n");
703       else
704         m_stream->PutCString(" {}\n");
705     }
706   } else {
707     if (ShouldPrintValueObject())
708       m_stream->EOL();
709   }
710 }
711 
712 bool ValueObjectPrinter::PrintChildrenOneLiner(bool hide_names) {
713   if (!GetMostSpecializedValue() || m_valobj == nullptr)
714     return false;
715 
716   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
717 
718   bool print_dotdotdot = false;
719   size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
720 
721   if (num_children) {
722     m_stream->PutChar('(');
723 
724     for (uint32_t idx = 0; idx < num_children; ++idx) {
725       lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
726       if (child_sp)
727         child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
728             m_options.m_use_dynamic, m_options.m_use_synthetic);
729       if (child_sp) {
730         if (idx)
731           m_stream->PutCString(", ");
732         if (!hide_names) {
733           const char *name = child_sp.get()->GetName().AsCString();
734           if (name && *name) {
735             m_stream->PutCString(name);
736             m_stream->PutCString(" = ");
737           }
738         }
739         child_sp->DumpPrintableRepresentation(
740             *m_stream, ValueObject::eValueObjectRepresentationStyleSummary,
741             m_options.m_format,
742             ValueObject::PrintableRepresentationSpecialCases::eDisable);
743       }
744     }
745 
746     if (print_dotdotdot)
747       m_stream->PutCString(", ...)");
748     else
749       m_stream->PutChar(')');
750   }
751   return true;
752 }
753 
754 void ValueObjectPrinter::PrintChildrenIfNeeded(bool value_printed,
755                                                bool summary_printed) {
756   // this flag controls whether we tried to display a description for this
757   // object and failed
758   // if that happens, we want to display the children, if any
759   bool is_failed_description =
760       !PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
761 
762   auto curr_ptr_depth = m_ptr_depth;
763   bool print_children =
764       ShouldPrintChildren(is_failed_description, curr_ptr_depth);
765   bool print_oneline =
766       (curr_ptr_depth.CanAllowExpansion() || m_options.m_show_types ||
767        !m_options.m_allow_oneliner_mode || m_options.m_flat_output ||
768        (m_options.m_pointer_as_array) || m_options.m_show_location)
769           ? false
770           : DataVisualization::ShouldPrintAsOneLiner(*m_valobj);
771   bool is_instance_ptr = IsInstancePointer();
772   uint64_t instance_ptr_value = LLDB_INVALID_ADDRESS;
773 
774   if (print_children && is_instance_ptr) {
775     instance_ptr_value = m_valobj->GetValueAsUnsigned(0);
776     if (m_printed_instance_pointers->count(instance_ptr_value)) {
777       // we already printed this instance-is-pointer thing, so don't expand it
778       m_stream->PutCString(" {...}\n");
779 
780       // we're done here - get out fast
781       return;
782     } else
783       m_printed_instance_pointers->emplace(
784           instance_ptr_value); // remember this guy for future reference
785   }
786 
787   if (print_children) {
788     if (print_oneline) {
789       m_stream->PutChar(' ');
790       PrintChildrenOneLiner(false);
791       m_stream->EOL();
792     } else
793       PrintChildren(value_printed, summary_printed, curr_ptr_depth);
794   } else if (m_curr_depth >= m_options.m_max_depth && IsAggregate() &&
795              ShouldPrintValueObject()) {
796     m_stream->PutCString("{...}\n");
797   } else
798     m_stream->EOL();
799 }
800 
801 bool ValueObjectPrinter::ShouldPrintValidation() {
802   return m_options.m_run_validator;
803 }
804 
805 bool ValueObjectPrinter::PrintValidationMarkerIfNeeded() {
806   if (!ShouldPrintValidation())
807     return false;
808 
809   m_validation = m_valobj->GetValidationStatus();
810 
811   if (TypeValidatorResult::Failure == m_validation.first) {
812     m_stream->Printf("! ");
813     return true;
814   }
815 
816   return false;
817 }
818 
819 bool ValueObjectPrinter::PrintValidationErrorIfNeeded() {
820   if (!ShouldPrintValidation())
821     return false;
822 
823   if (TypeValidatorResult::Success == m_validation.first)
824     return false;
825 
826   if (m_validation.second.empty())
827     m_validation.second.assign("unknown error");
828 
829   m_stream->Printf(" ! validation error: %s", m_validation.second.c_str());
830   m_stream->EOL();
831 
832   return true;
833 }
834