lldb/source/DataFormatters/ValueObjectPrinter.cpp

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