You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
795 lines
26 KiB
795 lines
26 KiB
//===-- ValueObjectPrinter.cpp --------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/DataFormatters/ValueObjectPrinter.h"
|
|
|
|
#include "lldb/Core/ValueObject.h"
|
|
#include "lldb/DataFormatters/DataVisualization.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Target/Language.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s) {
|
|
if (valobj) {
|
|
DumpValueObjectOptions options(*valobj);
|
|
Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
|
|
} else {
|
|
DumpValueObjectOptions options;
|
|
Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
|
|
}
|
|
}
|
|
|
|
ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s,
|
|
const DumpValueObjectOptions &options) {
|
|
Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
|
|
}
|
|
|
|
ValueObjectPrinter::ValueObjectPrinter(
|
|
ValueObject *valobj, Stream *s, const DumpValueObjectOptions &options,
|
|
const DumpValueObjectOptions::PointerDepth &ptr_depth, uint32_t curr_depth,
|
|
InstancePointersSetSP printed_instance_pointers) {
|
|
Init(valobj, s, options, ptr_depth, curr_depth, printed_instance_pointers);
|
|
}
|
|
|
|
void ValueObjectPrinter::Init(
|
|
ValueObject *valobj, Stream *s, const DumpValueObjectOptions &options,
|
|
const DumpValueObjectOptions::PointerDepth &ptr_depth, uint32_t curr_depth,
|
|
InstancePointersSetSP printed_instance_pointers) {
|
|
m_orig_valobj = valobj;
|
|
m_valobj = nullptr;
|
|
m_stream = s;
|
|
m_options = options;
|
|
m_ptr_depth = ptr_depth;
|
|
m_curr_depth = curr_depth;
|
|
assert(m_orig_valobj && "cannot print a NULL ValueObject");
|
|
assert(m_stream && "cannot print to a NULL Stream");
|
|
m_should_print = eLazyBoolCalculate;
|
|
m_is_nil = eLazyBoolCalculate;
|
|
m_is_uninit = eLazyBoolCalculate;
|
|
m_is_ptr = eLazyBoolCalculate;
|
|
m_is_ref = eLazyBoolCalculate;
|
|
m_is_aggregate = eLazyBoolCalculate;
|
|
m_is_instance_ptr = eLazyBoolCalculate;
|
|
m_summary_formatter = {nullptr, false};
|
|
m_value.assign("");
|
|
m_summary.assign("");
|
|
m_error.assign("");
|
|
m_val_summary_ok = false;
|
|
m_printed_instance_pointers =
|
|
printed_instance_pointers
|
|
? printed_instance_pointers
|
|
: InstancePointersSetSP(new InstancePointersSet());
|
|
}
|
|
|
|
bool ValueObjectPrinter::PrintValueObject() {
|
|
if (!GetMostSpecializedValue() || m_valobj == nullptr)
|
|
return false;
|
|
|
|
if (ShouldPrintValueObject()) {
|
|
PrintLocationIfNeeded();
|
|
m_stream->Indent();
|
|
|
|
PrintDecl();
|
|
}
|
|
|
|
bool value_printed = false;
|
|
bool summary_printed = false;
|
|
|
|
m_val_summary_ok =
|
|
PrintValueAndSummaryIfNeeded(value_printed, summary_printed);
|
|
|
|
if (m_val_summary_ok)
|
|
PrintChildrenIfNeeded(value_printed, summary_printed);
|
|
else
|
|
m_stream->EOL();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ValueObjectPrinter::GetMostSpecializedValue() {
|
|
if (m_valobj)
|
|
return true;
|
|
bool update_success = m_orig_valobj->UpdateValueIfNeeded(true);
|
|
if (!update_success) {
|
|
m_valobj = m_orig_valobj;
|
|
} else {
|
|
if (m_orig_valobj->IsDynamic()) {
|
|
if (m_options.m_use_dynamic == eNoDynamicValues) {
|
|
ValueObject *static_value = m_orig_valobj->GetStaticValue().get();
|
|
if (static_value)
|
|
m_valobj = static_value;
|
|
else
|
|
m_valobj = m_orig_valobj;
|
|
} else
|
|
m_valobj = m_orig_valobj;
|
|
} else {
|
|
if (m_options.m_use_dynamic != eNoDynamicValues) {
|
|
ValueObject *dynamic_value =
|
|
m_orig_valobj->GetDynamicValue(m_options.m_use_dynamic).get();
|
|
if (dynamic_value)
|
|
m_valobj = dynamic_value;
|
|
else
|
|
m_valobj = m_orig_valobj;
|
|
} else
|
|
m_valobj = m_orig_valobj;
|
|
}
|
|
|
|
if (m_valobj->IsSynthetic()) {
|
|
if (!m_options.m_use_synthetic) {
|
|
ValueObject *non_synthetic = m_valobj->GetNonSyntheticValue().get();
|
|
if (non_synthetic)
|
|
m_valobj = non_synthetic;
|
|
}
|
|
} else {
|
|
if (m_options.m_use_synthetic) {
|
|
ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
|
|
if (synthetic)
|
|
m_valobj = synthetic;
|
|
}
|
|
}
|
|
}
|
|
m_compiler_type = m_valobj->GetCompilerType();
|
|
m_type_flags = m_compiler_type.GetTypeInfo();
|
|
return true;
|
|
}
|
|
|
|
const char *ValueObjectPrinter::GetDescriptionForDisplay() {
|
|
const char *str = m_valobj->GetObjectDescription();
|
|
if (!str)
|
|
str = m_valobj->GetSummaryAsCString();
|
|
if (!str)
|
|
str = m_valobj->GetValueAsCString();
|
|
return str;
|
|
}
|
|
|
|
const char *ValueObjectPrinter::GetRootNameForDisplay() {
|
|
const char *root_valobj_name = m_options.m_root_valobj_name.empty()
|
|
? m_valobj->GetName().AsCString()
|
|
: m_options.m_root_valobj_name.c_str();
|
|
return root_valobj_name ? root_valobj_name : "";
|
|
}
|
|
|
|
bool ValueObjectPrinter::ShouldPrintValueObject() {
|
|
if (m_should_print == eLazyBoolCalculate)
|
|
m_should_print =
|
|
(!m_options.m_flat_output || m_type_flags.Test(eTypeHasValue))
|
|
? eLazyBoolYes
|
|
: eLazyBoolNo;
|
|
return m_should_print == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::IsNil() {
|
|
if (m_is_nil == eLazyBoolCalculate)
|
|
m_is_nil = m_valobj->IsNilReference() ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_nil == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::IsUninitialized() {
|
|
if (m_is_uninit == eLazyBoolCalculate)
|
|
m_is_uninit =
|
|
m_valobj->IsUninitializedReference() ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_uninit == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::IsPtr() {
|
|
if (m_is_ptr == eLazyBoolCalculate)
|
|
m_is_ptr = m_type_flags.Test(eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_ptr == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::IsRef() {
|
|
if (m_is_ref == eLazyBoolCalculate)
|
|
m_is_ref = m_type_flags.Test(eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_ref == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::IsAggregate() {
|
|
if (m_is_aggregate == eLazyBoolCalculate)
|
|
m_is_aggregate =
|
|
m_type_flags.Test(eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_aggregate == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::IsInstancePointer() {
|
|
// you need to do this check on the value's clang type
|
|
if (m_is_instance_ptr == eLazyBoolCalculate)
|
|
m_is_instance_ptr = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() &
|
|
eTypeInstanceIsPointer) != 0
|
|
? eLazyBoolYes
|
|
: eLazyBoolNo;
|
|
if ((eLazyBoolYes == m_is_instance_ptr) && m_valobj->IsBaseClass())
|
|
m_is_instance_ptr = eLazyBoolNo;
|
|
return m_is_instance_ptr == eLazyBoolYes;
|
|
}
|
|
|
|
bool ValueObjectPrinter::PrintLocationIfNeeded() {
|
|
if (m_options.m_show_location) {
|
|
m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ValueObjectPrinter::PrintDecl() {
|
|
bool show_type = true;
|
|
// if we are at the root-level and been asked to hide the root's type, then
|
|
// hide it
|
|
if (m_curr_depth == 0 && m_options.m_hide_root_type)
|
|
show_type = false;
|
|
else
|
|
// otherwise decide according to the usual rules (asked to show types -
|
|
// always at the root level)
|
|
show_type = m_options.m_show_types ||
|
|
(m_curr_depth == 0 && !m_options.m_flat_output);
|
|
|
|
StreamString typeName;
|
|
|
|
// always show the type at the root level if it is invalid
|
|
if (show_type) {
|
|
// Some ValueObjects don't have types (like registers sets). Only print the
|
|
// type if there is one to print
|
|
ConstString type_name;
|
|
if (m_compiler_type.IsValid()) {
|
|
type_name = m_options.m_use_type_display_name
|
|
? m_valobj->GetDisplayTypeName()
|
|
: m_valobj->GetQualifiedTypeName();
|
|
} else {
|
|
// only show an invalid type name if the user explicitly triggered
|
|
// show_type
|
|
if (m_options.m_show_types)
|
|
type_name = ConstString("<invalid type>");
|
|
}
|
|
|
|
if (type_name) {
|
|
std::string type_name_str(type_name.GetCString());
|
|
if (m_options.m_hide_pointer_value) {
|
|
for (auto iter = type_name_str.find(" *"); iter != std::string::npos;
|
|
iter = type_name_str.find(" *")) {
|
|
type_name_str.erase(iter, 2);
|
|
}
|
|
}
|
|
typeName << type_name_str.c_str();
|
|
}
|
|
}
|
|
|
|
StreamString varName;
|
|
|
|
if (!m_options.m_hide_name) {
|
|
if (m_options.m_flat_output)
|
|
m_valobj->GetExpressionPath(varName);
|
|
else
|
|
varName << GetRootNameForDisplay();
|
|
}
|
|
|
|
bool decl_printed = false;
|
|
if (!m_options.m_decl_printing_helper) {
|
|
// if the user didn't give us a custom helper, pick one based upon the
|
|
// language, either the one that this printer is bound to, or the preferred
|
|
// one for the ValueObject
|
|
lldb::LanguageType lang_type =
|
|
(m_options.m_varformat_language == lldb::eLanguageTypeUnknown)
|
|
? m_valobj->GetPreferredDisplayLanguage()
|
|
: m_options.m_varformat_language;
|
|
if (Language *lang_plugin = Language::FindPlugin(lang_type)) {
|
|
m_options.m_decl_printing_helper = lang_plugin->GetDeclPrintingHelper();
|
|
}
|
|
}
|
|
|
|
if (m_options.m_decl_printing_helper) {
|
|
ConstString type_name_cstr(typeName.GetString());
|
|
ConstString var_name_cstr(varName.GetString());
|
|
|
|
StreamString dest_stream;
|
|
if (m_options.m_decl_printing_helper(type_name_cstr, var_name_cstr,
|
|
m_options, dest_stream)) {
|
|
decl_printed = true;
|
|
m_stream->PutCString(dest_stream.GetString());
|
|
}
|
|
}
|
|
|
|
// if the helper failed, or there is none, do a default thing
|
|
if (!decl_printed) {
|
|
if (!typeName.Empty())
|
|
m_stream->Printf("(%s) ", typeName.GetData());
|
|
if (!varName.Empty())
|
|
m_stream->Printf("%s =", varName.GetData());
|
|
else if (!m_options.m_hide_name)
|
|
m_stream->Printf(" =");
|
|
}
|
|
}
|
|
|
|
bool ValueObjectPrinter::CheckScopeIfNeeded() {
|
|
if (m_options.m_scope_already_checked)
|
|
return true;
|
|
return m_valobj->IsInScope();
|
|
}
|
|
|
|
TypeSummaryImpl *ValueObjectPrinter::GetSummaryFormatter(bool null_if_omitted) {
|
|
if (!m_summary_formatter.second) {
|
|
TypeSummaryImpl *entry = m_options.m_summary_sp
|
|
? m_options.m_summary_sp.get()
|
|
: m_valobj->GetSummaryFormat().get();
|
|
|
|
if (m_options.m_omit_summary_depth > 0)
|
|
entry = nullptr;
|
|
m_summary_formatter.first = entry;
|
|
m_summary_formatter.second = true;
|
|
}
|
|
if (m_options.m_omit_summary_depth > 0 && null_if_omitted)
|
|
return nullptr;
|
|
return m_summary_formatter.first;
|
|
}
|
|
|
|
static bool IsPointerValue(const CompilerType &type) {
|
|
Flags type_flags(type.GetTypeInfo());
|
|
if (type_flags.AnySet(eTypeInstanceIsPointer | eTypeIsPointer))
|
|
return type_flags.AllClear(eTypeIsBuiltIn);
|
|
return false;
|
|
}
|
|
|
|
void ValueObjectPrinter::GetValueSummaryError(std::string &value,
|
|
std::string &summary,
|
|
std::string &error) {
|
|
lldb::Format format = m_options.m_format;
|
|
// if I am printing synthetized elements, apply the format to those elements
|
|
// only
|
|
if (m_options.m_pointer_as_array)
|
|
m_valobj->GetValueAsCString(lldb::eFormatDefault, value);
|
|
else if (format != eFormatDefault && format != m_valobj->GetFormat())
|
|
m_valobj->GetValueAsCString(format, value);
|
|
else {
|
|
const char *val_cstr = m_valobj->GetValueAsCString();
|
|
if (val_cstr)
|
|
value.assign(val_cstr);
|
|
}
|
|
const char *err_cstr = m_valobj->GetError().AsCString();
|
|
if (err_cstr)
|
|
error.assign(err_cstr);
|
|
|
|
if (!ShouldPrintValueObject())
|
|
return;
|
|
|
|
if (IsNil()) {
|
|
lldb::LanguageType lang_type =
|
|
(m_options.m_varformat_language == lldb::eLanguageTypeUnknown)
|
|
? m_valobj->GetPreferredDisplayLanguage()
|
|
: m_options.m_varformat_language;
|
|
if (Language *lang_plugin = Language::FindPlugin(lang_type)) {
|
|
summary.assign(lang_plugin->GetNilReferenceSummaryString().str());
|
|
} else {
|
|
// We treat C as the fallback language rather than as a separate Language
|
|
// plugin.
|
|
summary.assign("NULL");
|
|
}
|
|
} else if (IsUninitialized()) {
|
|
summary.assign("<uninitialized>");
|
|
} else if (m_options.m_omit_summary_depth == 0) {
|
|
TypeSummaryImpl *entry = GetSummaryFormatter();
|
|
if (entry) {
|
|
m_valobj->GetSummaryAsCString(entry, summary,
|
|
m_options.m_varformat_language);
|
|
} else {
|
|
const char *sum_cstr =
|
|
m_valobj->GetSummaryAsCString(m_options.m_varformat_language);
|
|
if (sum_cstr)
|
|
summary.assign(sum_cstr);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ValueObjectPrinter::PrintValueAndSummaryIfNeeded(bool &value_printed,
|
|
bool &summary_printed) {
|
|
bool error_printed = false;
|
|
if (ShouldPrintValueObject()) {
|
|
if (!CheckScopeIfNeeded())
|
|
m_error.assign("out of scope");
|
|
if (m_error.empty()) {
|
|
GetValueSummaryError(m_value, m_summary, m_error);
|
|
}
|
|
if (m_error.size()) {
|
|
// we need to support scenarios in which it is actually fine for a value
|
|
// to have no type but - on the other hand - if we get an error *AND*
|
|
// have no type, we try to get out gracefully, since most often that
|
|
// combination means "could not resolve a type" and the default failure
|
|
// mode is quite ugly
|
|
if (!m_compiler_type.IsValid()) {
|
|
m_stream->Printf(" <could not resolve type>");
|
|
return false;
|
|
}
|
|
|
|
error_printed = true;
|
|
m_stream->Printf(" <%s>\n", m_error.c_str());
|
|
} else {
|
|
// Make sure we have a value and make sure the summary didn't specify
|
|
// that the value should not be printed - and do not print the value if
|
|
// this thing is nil (but show the value if the user passes a format
|
|
// explicitly)
|
|
TypeSummaryImpl *entry = GetSummaryFormatter();
|
|
const bool has_nil_or_uninitialized_summary =
|
|
(IsNil() || IsUninitialized()) && !m_summary.empty();
|
|
if (!has_nil_or_uninitialized_summary && !m_value.empty() &&
|
|
(entry == nullptr ||
|
|
(entry->DoesPrintValue(m_valobj) ||
|
|
m_options.m_format != eFormatDefault) ||
|
|
m_summary.empty()) &&
|
|
!m_options.m_hide_value) {
|
|
if (m_options.m_hide_pointer_value &&
|
|
IsPointerValue(m_valobj->GetCompilerType())) {
|
|
} else {
|
|
m_stream->Printf(" %s", m_value.c_str());
|
|
value_printed = true;
|
|
}
|
|
}
|
|
|
|
if (m_summary.size()) {
|
|
m_stream->Printf(" %s", m_summary.c_str());
|
|
summary_printed = true;
|
|
}
|
|
}
|
|
}
|
|
return !error_printed;
|
|
}
|
|
|
|
bool ValueObjectPrinter::PrintObjectDescriptionIfNeeded(bool value_printed,
|
|
bool summary_printed) {
|
|
if (ShouldPrintValueObject()) {
|
|
// let's avoid the overly verbose no description error for a nil thing
|
|
if (m_options.m_use_objc && !IsNil() && !IsUninitialized() &&
|
|
(!m_options.m_pointer_as_array)) {
|
|
if (!m_options.m_hide_value || !m_options.m_hide_name)
|
|
m_stream->Printf(" ");
|
|
const char *object_desc = nullptr;
|
|
if (value_printed || summary_printed)
|
|
object_desc = m_valobj->GetObjectDescription();
|
|
else
|
|
object_desc = GetDescriptionForDisplay();
|
|
if (object_desc && *object_desc) {
|
|
// If the description already ends with a \n don't add another one.
|
|
size_t object_end = strlen(object_desc) - 1;
|
|
if (object_desc[object_end] == '\n')
|
|
m_stream->Printf("%s", object_desc);
|
|
else
|
|
m_stream->Printf("%s\n", object_desc);
|
|
return true;
|
|
} else if (!value_printed && !summary_printed)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DumpValueObjectOptions::PointerDepth::CanAllowExpansion() const {
|
|
switch (m_mode) {
|
|
case Mode::Always:
|
|
case Mode::Default:
|
|
return m_count > 0;
|
|
case Mode::Never:
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ValueObjectPrinter::ShouldPrintChildren(
|
|
bool is_failed_description,
|
|
DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
|
|
const bool is_ref = IsRef();
|
|
const bool is_ptr = IsPtr();
|
|
const bool is_uninit = IsUninitialized();
|
|
|
|
if (is_uninit)
|
|
return false;
|
|
|
|
// if the user has specified an element count, always print children as it is
|
|
// explicit user demand being honored
|
|
if (m_options.m_pointer_as_array)
|
|
return true;
|
|
|
|
TypeSummaryImpl *entry = GetSummaryFormatter();
|
|
|
|
if (m_options.m_use_objc)
|
|
return false;
|
|
|
|
if (is_failed_description || m_curr_depth < m_options.m_max_depth) {
|
|
// We will show children for all concrete types. We won't show pointer
|
|
// contents unless a pointer depth has been specified. We won't reference
|
|
// contents unless the reference is the root object (depth of zero).
|
|
|
|
// Use a new temporary pointer depth in case we override the current
|
|
// pointer depth below...
|
|
|
|
if (is_ptr || is_ref) {
|
|
// We have a pointer or reference whose value is an address. Make sure
|
|
// that address is not NULL
|
|
AddressType ptr_address_type;
|
|
if (m_valobj->GetPointerValue(&ptr_address_type) == 0)
|
|
return false;
|
|
|
|
const bool is_root_level = m_curr_depth == 0;
|
|
|
|
if (is_ref && is_root_level) {
|
|
// If this is the root object (depth is zero) that we are showing and
|
|
// it is a reference, and no pointer depth has been supplied print out
|
|
// what it references. Don't do this at deeper depths otherwise we can
|
|
// end up with infinite recursion...
|
|
return true;
|
|
}
|
|
|
|
return curr_ptr_depth.CanAllowExpansion();
|
|
}
|
|
|
|
return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ValueObjectPrinter::ShouldExpandEmptyAggregates() {
|
|
TypeSummaryImpl *entry = GetSummaryFormatter();
|
|
|
|
if (!entry)
|
|
return true;
|
|
|
|
return entry->DoesPrintEmptyAggregates();
|
|
}
|
|
|
|
ValueObject *ValueObjectPrinter::GetValueObjectForChildrenGeneration() {
|
|
return m_valobj;
|
|
}
|
|
|
|
void ValueObjectPrinter::PrintChildrenPreamble() {
|
|
if (m_options.m_flat_output) {
|
|
if (ShouldPrintValueObject())
|
|
m_stream->EOL();
|
|
} else {
|
|
if (ShouldPrintValueObject())
|
|
m_stream->PutCString(IsRef() ? ": {\n" : " {\n");
|
|
m_stream->IndentMore();
|
|
}
|
|
}
|
|
|
|
void ValueObjectPrinter::PrintChild(
|
|
ValueObjectSP child_sp,
|
|
const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
|
|
const uint32_t consumed_depth = (!m_options.m_pointer_as_array) ? 1 : 0;
|
|
const bool does_consume_ptr_depth =
|
|
((IsPtr() && !m_options.m_pointer_as_array) || IsRef());
|
|
|
|
DumpValueObjectOptions child_options(m_options);
|
|
child_options.SetFormat(m_options.m_format)
|
|
.SetSummary()
|
|
.SetRootValueObjectName();
|
|
child_options.SetScopeChecked(true)
|
|
.SetHideName(m_options.m_hide_name)
|
|
.SetHideValue(m_options.m_hide_value)
|
|
.SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1
|
|
? child_options.m_omit_summary_depth -
|
|
consumed_depth
|
|
: 0)
|
|
.SetElementCount(0);
|
|
|
|
if (child_sp.get()) {
|
|
ValueObjectPrinter child_printer(
|
|
child_sp.get(), m_stream, child_options,
|
|
does_consume_ptr_depth ? --curr_ptr_depth : curr_ptr_depth,
|
|
m_curr_depth + consumed_depth, m_printed_instance_pointers);
|
|
child_printer.PrintValueObject();
|
|
}
|
|
}
|
|
|
|
uint32_t ValueObjectPrinter::GetMaxNumChildrenToPrint(bool &print_dotdotdot) {
|
|
ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
if (m_options.m_pointer_as_array)
|
|
return m_options.m_pointer_as_array.m_element_count;
|
|
|
|
size_t num_children = synth_m_valobj->GetNumChildren();
|
|
print_dotdotdot = false;
|
|
if (num_children) {
|
|
const size_t max_num_children =
|
|
m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
|
|
|
|
if (num_children > max_num_children && !m_options.m_ignore_cap) {
|
|
print_dotdotdot = true;
|
|
return max_num_children;
|
|
}
|
|
}
|
|
return num_children;
|
|
}
|
|
|
|
void ValueObjectPrinter::PrintChildrenPostamble(bool print_dotdotdot) {
|
|
if (!m_options.m_flat_output) {
|
|
if (print_dotdotdot) {
|
|
m_valobj->GetTargetSP()
|
|
->GetDebugger()
|
|
.GetCommandInterpreter()
|
|
.ChildrenTruncated();
|
|
m_stream->Indent("...\n");
|
|
}
|
|
m_stream->IndentLess();
|
|
m_stream->Indent("}\n");
|
|
}
|
|
}
|
|
|
|
bool ValueObjectPrinter::ShouldPrintEmptyBrackets(bool value_printed,
|
|
bool summary_printed) {
|
|
ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
if (!IsAggregate())
|
|
return false;
|
|
|
|
if (!m_options.m_reveal_empty_aggregates) {
|
|
if (value_printed || summary_printed)
|
|
return false;
|
|
}
|
|
|
|
if (synth_m_valobj->MightHaveChildren())
|
|
return true;
|
|
|
|
if (m_val_summary_ok)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static constexpr size_t PhysicalIndexForLogicalIndex(size_t base, size_t stride,
|
|
size_t logical) {
|
|
return base + logical * stride;
|
|
}
|
|
|
|
ValueObjectSP ValueObjectPrinter::GenerateChild(ValueObject *synth_valobj,
|
|
size_t idx) {
|
|
if (m_options.m_pointer_as_array) {
|
|
// if generating pointer-as-array children, use GetSyntheticArrayMember
|
|
return synth_valobj->GetSyntheticArrayMember(
|
|
PhysicalIndexForLogicalIndex(
|
|
m_options.m_pointer_as_array.m_base_element,
|
|
m_options.m_pointer_as_array.m_stride, idx),
|
|
true);
|
|
} else {
|
|
// otherwise, do the usual thing
|
|
return synth_valobj->GetChildAtIndex(idx, true);
|
|
}
|
|
}
|
|
|
|
void ValueObjectPrinter::PrintChildren(
|
|
bool value_printed, bool summary_printed,
|
|
const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
|
|
ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
bool print_dotdotdot = false;
|
|
size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
|
|
if (num_children) {
|
|
bool any_children_printed = false;
|
|
|
|
for (size_t idx = 0; idx < num_children; ++idx) {
|
|
if (ValueObjectSP child_sp = GenerateChild(synth_m_valobj, idx)) {
|
|
if (!any_children_printed) {
|
|
PrintChildrenPreamble();
|
|
any_children_printed = true;
|
|
}
|
|
PrintChild(child_sp, curr_ptr_depth);
|
|
}
|
|
}
|
|
|
|
if (any_children_printed)
|
|
PrintChildrenPostamble(print_dotdotdot);
|
|
else {
|
|
if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
|
|
if (ShouldPrintValueObject())
|
|
m_stream->PutCString(" {}\n");
|
|
else
|
|
m_stream->EOL();
|
|
} else
|
|
m_stream->EOL();
|
|
}
|
|
} else if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
|
|
// Aggregate, no children...
|
|
if (ShouldPrintValueObject()) {
|
|
// if it has a synthetic value, then don't print {}, the synthetic
|
|
// children are probably only being used to vend a value
|
|
if (m_valobj->DoesProvideSyntheticValue() ||
|
|
!ShouldExpandEmptyAggregates())
|
|
m_stream->PutCString("\n");
|
|
else
|
|
m_stream->PutCString(" {}\n");
|
|
}
|
|
} else {
|
|
if (ShouldPrintValueObject())
|
|
m_stream->EOL();
|
|
}
|
|
}
|
|
|
|
bool ValueObjectPrinter::PrintChildrenOneLiner(bool hide_names) {
|
|
if (!GetMostSpecializedValue() || m_valobj == nullptr)
|
|
return false;
|
|
|
|
ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
bool print_dotdotdot = false;
|
|
size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
|
|
|
|
if (num_children) {
|
|
m_stream->PutChar('(');
|
|
|
|
for (uint32_t idx = 0; idx < num_children; ++idx) {
|
|
lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
|
|
if (child_sp)
|
|
child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
|
|
m_options.m_use_dynamic, m_options.m_use_synthetic);
|
|
if (child_sp) {
|
|
if (idx)
|
|
m_stream->PutCString(", ");
|
|
if (!hide_names) {
|
|
const char *name = child_sp.get()->GetName().AsCString();
|
|
if (name && *name) {
|
|
m_stream->PutCString(name);
|
|
m_stream->PutCString(" = ");
|
|
}
|
|
}
|
|
child_sp->DumpPrintableRepresentation(
|
|
*m_stream, ValueObject::eValueObjectRepresentationStyleSummary,
|
|
m_options.m_format,
|
|
ValueObject::PrintableRepresentationSpecialCases::eDisable);
|
|
}
|
|
}
|
|
|
|
if (print_dotdotdot)
|
|
m_stream->PutCString(", ...)");
|
|
else
|
|
m_stream->PutChar(')');
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ValueObjectPrinter::PrintChildrenIfNeeded(bool value_printed,
|
|
bool summary_printed) {
|
|
// This flag controls whether we tried to display a description for this
|
|
// object and failed if that happens, we want to display the children if any.
|
|
bool is_failed_description =
|
|
!PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
|
|
|
|
DumpValueObjectOptions::PointerDepth curr_ptr_depth = m_ptr_depth;
|
|
const bool print_children =
|
|
ShouldPrintChildren(is_failed_description, curr_ptr_depth);
|
|
const bool print_oneline =
|
|
(curr_ptr_depth.CanAllowExpansion() || m_options.m_show_types ||
|
|
!m_options.m_allow_oneliner_mode || m_options.m_flat_output ||
|
|
(m_options.m_pointer_as_array) || m_options.m_show_location)
|
|
? false
|
|
: DataVisualization::ShouldPrintAsOneLiner(*m_valobj);
|
|
if (print_children && IsInstancePointer()) {
|
|
uint64_t instance_ptr_value = m_valobj->GetValueAsUnsigned(0);
|
|
if (m_printed_instance_pointers->count(instance_ptr_value)) {
|
|
// We already printed this instance-is-pointer thing, so don't expand it.
|
|
m_stream->PutCString(" {...}\n");
|
|
return;
|
|
} else {
|
|
// Remember this guy for future reference.
|
|
m_printed_instance_pointers->emplace(instance_ptr_value);
|
|
}
|
|
}
|
|
|
|
if (print_children) {
|
|
if (print_oneline) {
|
|
m_stream->PutChar(' ');
|
|
PrintChildrenOneLiner(false);
|
|
m_stream->EOL();
|
|
} else
|
|
PrintChildren(value_printed, summary_printed, curr_ptr_depth);
|
|
} else if (m_curr_depth >= m_options.m_max_depth && IsAggregate() &&
|
|
ShouldPrintValueObject()) {
|
|
m_stream->PutCString("{...}\n");
|
|
} else
|
|
m_stream->EOL();
|
|
}
|