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