contrib/llvm/tools/lldb/source/DataFormatters/ValueObjectPrinter.cpp

   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 the
 248     // 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 but - on the other hand - if we get an error *AND*
 406       // have no type, we try to get out gracefully, since most often that
 407       // combination means "could not resolve a type" and the default failure
 408       // mode is quite ugly
 409       if (!m_compiler_type.IsValid()) {
 410         m_stream->Printf(" <could not resolve type>");
 411         return false;
 412       }
 413
 414       error_printed = true;
 415       m_stream->Printf(" <%s>\n", m_error.c_str());
 416     } else {
 417       // Make sure we have a value and make sure the summary didn't specify
 418       // that the value should not be printed - and do not print the value if
 419       // this thing is nil (but show the value if the user passes a format
 420       // explicitly)
 421       TypeSummaryImpl *entry = GetSummaryFormatter();
 422       if (!IsNil() && !IsUninitialized() && !m_value.empty() &&
 423           (entry == NULL || (entry->DoesPrintValue(m_valobj) ||
 424                              m_options.m_format != eFormatDefault) ||
 425            m_summary.empty()) &&
 426           !m_options.m_hide_value) {
 427         if (m_options.m_hide_pointer_value &&
 428             IsPointerValue(m_valobj->GetCompilerType())) {
 429         } else {
 430           m_stream->Printf(" %s", m_value.c_str());
 431           value_printed = true;
 432         }
 433       }
 434
 435       if (m_summary.size()) {
 436         m_stream->Printf(" %s", m_summary.c_str());
 437         summary_printed = true;
 438       }
 439     }
 440   }
 441   return !error_printed;
 442 }
 443
 444 bool ValueObjectPrinter::PrintObjectDescriptionIfNeeded(bool value_printed,
 445                                                         bool summary_printed) {
 446   if (ShouldPrintValueObject()) {
 447     // let's avoid the overly verbose no description error for a nil thing
 448     if (m_options.m_use_objc && !IsNil() && !IsUninitialized() &&
 449         (!m_options.m_pointer_as_array)) {
 450       if (!m_options.m_hide_value || !m_options.m_hide_name)
 451         m_stream->Printf(" ");
 452       const char *object_desc = nullptr;
 453       if (value_printed || summary_printed)
 454         object_desc = m_valobj->GetObjectDescription();
 455       else
 456         object_desc = GetDescriptionForDisplay();
 457       if (object_desc && *object_desc) {
 458         // If the description already ends with a \n don't add another one.
 459         size_t object_end = strlen(object_desc) - 1;
 460         if (object_desc[object_end] == '\n')
 461             m_stream->Printf("%s", object_desc);
 462         else
 463             m_stream->Printf("%s\n", object_desc);
 464         return true;
 465       } else if (value_printed == false && summary_printed == false)
 466         return true;
 467       else
 468         return false;
 469     }
 470   }
 471   return true;
 472 }
 473
 474 bool DumpValueObjectOptions::PointerDepth::CanAllowExpansion() const {
 475   switch (m_mode) {
 476   case Mode::Always:
 477   case Mode::Default:
 478     return m_count > 0;
 479   case Mode::Never:
 480     return false;
 481   }
 482   return false;
 483 }
 484
 485 bool ValueObjectPrinter::ShouldPrintChildren(
 486     bool is_failed_description,
 487     DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
 488   const bool is_ref = IsRef();
 489   const bool is_ptr = IsPtr();
 490   const bool is_uninit = IsUninitialized();
 491
 492   if (is_uninit)
 493     return false;
 494
 495   // if the user has specified an element count, always print children as it is
 496   // explicit user demand being honored
 497   if (m_options.m_pointer_as_array)
 498     return true;
 499
 500   TypeSummaryImpl *entry = GetSummaryFormatter();
 501
 502   if (m_options.m_use_objc)
 503     return false;
 504
 505   if (is_failed_description || m_curr_depth < m_options.m_max_depth) {
 506     // We will show children for all concrete types. We won't show pointer
 507     // contents unless a pointer depth has been specified. We won't reference
 508     // contents unless the reference is the root object (depth of zero).
 509
 510     // Use a new temporary pointer depth in case we override the current
 511     // pointer depth below...
 512
 513     if (is_ptr || is_ref) {
 514       // We have a pointer or reference whose value is an address. Make sure
 515       // that address is not NULL
 516       AddressType ptr_address_type;
 517       if (m_valobj->GetPointerValue(&ptr_address_type) == 0)
 518         return false;
 519
 520       const bool is_root_level = m_curr_depth == 0;
 521
 522       if (is_ref && is_root_level) {
 523         // If this is the root object (depth is zero) that we are showing and
 524         // it is a reference, and no pointer depth has been supplied print out
 525         // what it references. Don't do this at deeper depths otherwise we can
 526         // end up with infinite recursion...
 527         return true;
 528       }
 529
 530       return curr_ptr_depth.CanAllowExpansion();
 531     }
 532
 533     return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
 534   }
 535   return false;
 536 }
 537
 538 bool ValueObjectPrinter::ShouldExpandEmptyAggregates() {
 539   TypeSummaryImpl *entry = GetSummaryFormatter();
 540
 541   if (!entry)
 542     return true;
 543
 544   return entry->DoesPrintEmptyAggregates();
 545 }
 546
 547 ValueObject *ValueObjectPrinter::GetValueObjectForChildrenGeneration() {
 548   return m_valobj;
 549 }
 550
 551 void ValueObjectPrinter::PrintChildrenPreamble() {
 552   if (m_options.m_flat_output) {
 553     if (ShouldPrintValueObject())
 554       m_stream->EOL();
 555   } else {
 556     if (ShouldPrintValueObject())
 557       m_stream->PutCString(IsRef() ? ": {\n" : " {\n");
 558     m_stream->IndentMore();
 559   }
 560 }
 561
 562 void ValueObjectPrinter::PrintChild(
 563     ValueObjectSP child_sp,
 564     const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
 565   const uint32_t consumed_depth = (!m_options.m_pointer_as_array) ? 1 : 0;
 566   const bool does_consume_ptr_depth =
 567       ((IsPtr() && !m_options.m_pointer_as_array) || IsRef());
 568
 569   DumpValueObjectOptions child_options(m_options);
 570   child_options.SetFormat(m_options.m_format)
 571       .SetSummary()
 572       .SetRootValueObjectName();
 573   child_options.SetScopeChecked(true)
 574       .SetHideName(m_options.m_hide_name)
 575       .SetHideValue(m_options.m_hide_value)
 576       .SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1
 577                                ? child_options.m_omit_summary_depth -
 578                                      consumed_depth
 579                                : 0)
 580       .SetElementCount(0);
 581
 582   if (child_sp.get()) {
 583     ValueObjectPrinter child_printer(
 584         child_sp.get(), m_stream, child_options,
 585         does_consume_ptr_depth ? --curr_ptr_depth : curr_ptr_depth,
 586         m_curr_depth + consumed_depth, m_printed_instance_pointers);
 587     child_printer.PrintValueObject();
 588   }
 589 }
 590
 591 uint32_t ValueObjectPrinter::GetMaxNumChildrenToPrint(bool &print_dotdotdot) {
 592   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
 593
 594   if (m_options.m_pointer_as_array)
 595     return m_options.m_pointer_as_array.m_element_count;
 596
 597   size_t num_children = synth_m_valobj->GetNumChildren();
 598   print_dotdotdot = false;
 599   if (num_children) {
 600     const size_t max_num_children =
 601         m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
 602
 603     if (num_children > max_num_children && !m_options.m_ignore_cap) {
 604       print_dotdotdot = true;
 605       return max_num_children;
 606     }
 607   }
 608   return num_children;
 609 }
 610
 611 void ValueObjectPrinter::PrintChildrenPostamble(bool print_dotdotdot) {
 612   if (!m_options.m_flat_output) {
 613     if (print_dotdotdot) {
 614       m_valobj->GetTargetSP()
 615           ->GetDebugger()
 616           .GetCommandInterpreter()
 617           .ChildrenTruncated();
 618       m_stream->Indent("...\n");
 619     }
 620     m_stream->IndentLess();
 621     m_stream->Indent("}\n");
 622   }
 623 }
 624
 625 bool ValueObjectPrinter::ShouldPrintEmptyBrackets(bool value_printed,
 626                                                   bool summary_printed) {
 627   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
 628
 629   if (!IsAggregate())
 630     return false;
 631
 632   if (m_options.m_reveal_empty_aggregates == false) {
 633     if (value_printed || summary_printed)
 634       return false;
 635   }
 636
 637   if (synth_m_valobj->MightHaveChildren())
 638     return true;
 639
 640   if (m_val_summary_ok)
 641     return false;
 642
 643   return true;
 644 }
 645
 646 static constexpr size_t PhysicalIndexForLogicalIndex(size_t base, size_t stride,
 647                                                      size_t logical) {
 648   return base + logical * stride;
 649 }
 650
 651 ValueObjectSP ValueObjectPrinter::GenerateChild(ValueObject *synth_valobj,
 652                                                 size_t idx) {
 653   if (m_options.m_pointer_as_array) {
 654     // if generating pointer-as-array children, use GetSyntheticArrayMember
 655     return synth_valobj->GetSyntheticArrayMember(
 656         PhysicalIndexForLogicalIndex(
 657             m_options.m_pointer_as_array.m_base_element,
 658             m_options.m_pointer_as_array.m_stride, idx),
 659         true);
 660   } else {
 661     // otherwise, do the usual thing
 662     return synth_valobj->GetChildAtIndex(idx, true);
 663   }
 664 }
 665
 666 void ValueObjectPrinter::PrintChildren(
 667     bool value_printed, bool summary_printed,
 668     const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
 669   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
 670
 671   bool print_dotdotdot = false;
 672   size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
 673   if (num_children) {
 674     bool any_children_printed = false;
 675
 676     for (size_t idx = 0; idx < num_children; ++idx) {
 677       if (ValueObjectSP child_sp = GenerateChild(synth_m_valobj, idx)) {
 678         if (!any_children_printed) {
 679           PrintChildrenPreamble();
 680           any_children_printed = true;
 681         }
 682         PrintChild(child_sp, curr_ptr_depth);
 683       }
 684     }
 685
 686     if (any_children_printed)
 687       PrintChildrenPostamble(print_dotdotdot);
 688     else {
 689       if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
 690         if (ShouldPrintValueObject())
 691           m_stream->PutCString(" {}\n");
 692         else
 693           m_stream->EOL();
 694       } else
 695         m_stream->EOL();
 696     }
 697   } else if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
 698     // Aggregate, no children...
 699     if (ShouldPrintValueObject()) {
 700       // if it has a synthetic value, then don't print {}, the synthetic
 701       // children are probably only being used to vend a value
 702       if (m_valobj->DoesProvideSyntheticValue() ||
 703           !ShouldExpandEmptyAggregates())
 704         m_stream->PutCString("\n");
 705       else
 706         m_stream->PutCString(" {}\n");
 707     }
 708   } else {
 709     if (ShouldPrintValueObject())
 710       m_stream->EOL();
 711   }
 712 }
 713
 714 bool ValueObjectPrinter::PrintChildrenOneLiner(bool hide_names) {
 715   if (!GetMostSpecializedValue() || m_valobj == nullptr)
 716     return false;
 717
 718   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
 719
 720   bool print_dotdotdot = false;
 721   size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
 722
 723   if (num_children) {
 724     m_stream->PutChar('(');
 725
 726     for (uint32_t idx = 0; idx < num_children; ++idx) {
 727       lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
 728       if (child_sp)
 729         child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
 730             m_options.m_use_dynamic, m_options.m_use_synthetic);
 731       if (child_sp) {
 732         if (idx)
 733           m_stream->PutCString(", ");
 734         if (!hide_names) {
 735           const char *name = child_sp.get()->GetName().AsCString();
 736           if (name && *name) {
 737             m_stream->PutCString(name);
 738             m_stream->PutCString(" = ");
 739           }
 740         }
 741         child_sp->DumpPrintableRepresentation(
 742             *m_stream, ValueObject::eValueObjectRepresentationStyleSummary,
 743             m_options.m_format,
 744             ValueObject::PrintableRepresentationSpecialCases::eDisable);
 745       }
 746     }
 747
 748     if (print_dotdotdot)
 749       m_stream->PutCString(", ...)");
 750     else
 751       m_stream->PutChar(')');
 752   }
 753   return true;
 754 }
 755
 756 void ValueObjectPrinter::PrintChildrenIfNeeded(bool value_printed,
 757                                                bool summary_printed) {
 758   // this flag controls whether we tried to display a description for this
 759   // object and failed if that happens, we want to display the children, if any
 760   bool is_failed_description =
 761       !PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
 762
 763   auto curr_ptr_depth = m_ptr_depth;
 764   bool print_children =
 765       ShouldPrintChildren(is_failed_description, curr_ptr_depth);
 766   bool print_oneline =
 767       (curr_ptr_depth.CanAllowExpansion() || m_options.m_show_types ||
 768        !m_options.m_allow_oneliner_mode || m_options.m_flat_output ||
 769        (m_options.m_pointer_as_array) || m_options.m_show_location)
 770           ? false
 771           : DataVisualization::ShouldPrintAsOneLiner(*m_valobj);
 772   bool is_instance_ptr = IsInstancePointer();
 773   uint64_t instance_ptr_value = LLDB_INVALID_ADDRESS;
 774
 775   if (print_children && is_instance_ptr) {
 776     instance_ptr_value = m_valobj->GetValueAsUnsigned(0);
 777     if (m_printed_instance_pointers->count(instance_ptr_value)) {
 778       // we already printed this instance-is-pointer thing, so don't expand it
 779       m_stream->PutCString(" {...}\n");
 780
 781       // we're done here - get out fast
 782       return;
 783     } else
 784       m_printed_instance_pointers->emplace(
 785           instance_ptr_value); // remember this guy for future reference
 786   }
 787
 788   if (print_children) {
 789     if (print_oneline) {
 790       m_stream->PutChar(' ');
 791       PrintChildrenOneLiner(false);
 792       m_stream->EOL();
 793     } else
 794       PrintChildren(value_printed, summary_printed, curr_ptr_depth);
 795   } else if (m_curr_depth >= m_options.m_max_depth && IsAggregate() &&
 796              ShouldPrintValueObject()) {
 797     m_stream->PutCString("{...}\n");
 798   } else
 799     m_stream->EOL();
 800 }
 801
 802 bool ValueObjectPrinter::ShouldPrintValidation() {
 803   return m_options.m_run_validator;
 804 }
 805
 806 bool ValueObjectPrinter::PrintValidationMarkerIfNeeded() {
 807   if (!ShouldPrintValidation())
 808     return false;
 809
 810   m_validation = m_valobj->GetValidationStatus();
 811
 812   if (TypeValidatorResult::Failure == m_validation.first) {
 813     m_stream->Printf("! ");
 814     return true;
 815   }
 816
 817   return false;
 818 }
 819
 820 bool ValueObjectPrinter::PrintValidationErrorIfNeeded() {
 821   if (!ShouldPrintValidation())
 822     return false;
 823
 824   if (TypeValidatorResult::Success == m_validation.first)
 825     return false;
 826
 827   if (m_validation.second.empty())
 828     m_validation.second.assign("unknown error");
 829
 830   m_stream->Printf(" ! validation error: %s", m_validation.second.c_str());
 831   m_stream->EOL();
 832
 833   return true;
 834 }