<rdar://problem/14393032>
DumpValueObject() 2.0
This checkin restores pre-Xcode5 functionality to the "po" (expr -O) command:
- expr now has a new --description-verbosity (-v) argument, which takes either compact or full as a value (-v is the same as -vfull)
When the full mode is on, "po" will show the extended output with type name, persistent variable name and value, as in
(lldb) expr -O -v -- foo
(id) $0 = 0x000000010010baf0 {
1 = 2;
2 = 3;
}
When -v is omitted, or -vcompact is passed, the Xcode5-style output will be shown, as in
(lldb) expr -O -- foo
{
1 = 2;
2 = 3;
}
- for a non-ObjectiveC object, LLDB will still try to retrieve a summary and/or value to display
(lldb) po 5
5
-v also works in this mode
(lldb) expr -O -vfull -- 5
(int) $4 = 5
On top of that, this is a major refactoring of the ValueObject printing code. The functionality is now factored into a ValueObjectPrinter class for easier maintenance in the future
DumpValueObject() was turned into an instance method ValueObject::Dump() which simply calls through to the printer code, Dump_Impl has been removed
Test case to follow
llvm-svn: 191694
diff --git a/lldb/source/DataFormatters/ValueObjectPrinter.cpp b/lldb/source/DataFormatters/ValueObjectPrinter.cpp
new file mode 100644
index 0000000..417b582
--- /dev/null
+++ b/lldb/source/DataFormatters/ValueObjectPrinter.cpp
@@ -0,0 +1,533 @@
+//===-- ValueObjectPrinter.cpp -------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/DataFormatters/ValueObjectPrinter.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/Debugger.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
+ Stream* s,
+ const DumpValueObjectOptions& options) :
+ m_orig_valobj(valobj),
+ m_valobj(nullptr),
+ m_stream(s),
+ options(options),
+ m_ptr_depth(options.m_max_ptr_depth),
+ m_curr_depth(0),
+ m_should_print(eLazyBoolCalculate),
+ m_is_nil(eLazyBoolCalculate),
+ m_is_ptr(eLazyBoolCalculate),
+ m_is_ref(eLazyBoolCalculate),
+ m_is_aggregate(eLazyBoolCalculate),
+ m_summary_formatter({nullptr,false}),
+ m_value(),
+ m_summary(),
+ m_error()
+{
+ assert (m_orig_valobj && "cannot print a NULL ValueObject");
+ assert (m_stream && "cannot print to a NULL Stream");
+}
+
+ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
+ Stream* s,
+ const DumpValueObjectOptions& options,
+ uint32_t ptr_depth,
+ uint32_t curr_depth) :
+ ValueObjectPrinter(valobj,s,options)
+{
+ m_ptr_depth = ptr_depth;
+ m_curr_depth = curr_depth;
+}
+
+bool
+ValueObjectPrinter::PrintValueObject ()
+{
+ if (!GetDynamicValueIfNeeded () || m_valobj == nullptr)
+ return false;
+
+ if (ShouldPrintValueObject())
+ {
+ PrintLocationIfNeeded();
+ m_stream->Indent();
+
+ bool show_type = PrintTypeIfNeeded();
+
+ PrintNameIfNeeded(show_type);
+ }
+
+ bool value_printed = false;
+ bool summary_printed = false;
+
+ bool val_summary_ok = PrintValueAndSummaryIfNeeded (value_printed,summary_printed);
+
+ if (val_summary_ok)
+ PrintChildrenIfNeeded (value_printed, summary_printed);
+
+ m_stream->EOL();
+
+ return true;
+}
+
+bool
+ValueObjectPrinter::GetDynamicValueIfNeeded ()
+{
+ bool update_success = m_orig_valobj->UpdateValueIfNeeded (true);
+ if (!update_success)
+ return false;
+ if (options.m_use_dynamic != eNoDynamicValues)
+ {
+ ValueObject *dynamic_value = m_orig_valobj->GetDynamicValue(options.m_use_dynamic).get();
+ if (dynamic_value)
+ m_valobj = dynamic_value;
+ else
+ m_valobj = m_orig_valobj;
+ }
+ else
+ m_valobj = m_orig_valobj;
+ m_clang_type = m_valobj->GetClangType();
+ m_type_flags = m_clang_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* if_fail)
+{
+ const char *root_valobj_name = options.m_root_valobj_name.empty() ?
+ m_valobj->GetName().AsCString() :
+ options.m_root_valobj_name.c_str();
+ return root_valobj_name ? root_valobj_name : if_fail;
+}
+
+bool
+ValueObjectPrinter::ShouldPrintValueObject ()
+{
+ if (m_should_print == eLazyBoolCalculate)
+ m_should_print = (options.m_flat_output == false || m_type_flags.Test (ClangASTType::eTypeHasValue)) ? eLazyBoolYes : eLazyBoolNo;
+ return m_should_print == eLazyBoolYes;
+}
+
+bool
+ValueObjectPrinter::IsNil ()
+{
+ if (m_is_nil == eLazyBoolCalculate)
+ m_is_nil = m_valobj->IsObjCNil() ? eLazyBoolYes : eLazyBoolNo;
+ return m_is_nil == eLazyBoolYes;
+}
+
+bool
+ValueObjectPrinter::IsPtr ()
+{
+ if (m_is_ptr == eLazyBoolCalculate)
+ m_is_ptr = m_type_flags.Test (ClangASTType::eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
+ return m_is_ptr == eLazyBoolYes;
+}
+
+bool
+ValueObjectPrinter::IsRef ()
+{
+ if (m_is_ref == eLazyBoolCalculate)
+ m_is_ref = m_type_flags.Test (ClangASTType::eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
+ return m_is_ref == eLazyBoolYes;
+}
+
+bool
+ValueObjectPrinter::IsAggregate ()
+{
+ if (m_is_aggregate == eLazyBoolCalculate)
+ m_is_aggregate = m_type_flags.Test (ClangASTType::eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
+ return m_is_aggregate == eLazyBoolYes;
+}
+
+bool
+ValueObjectPrinter::PrintLocationIfNeeded ()
+{
+ if (options.m_show_location)
+ {
+ m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
+ return true;
+ }
+ return false;
+}
+
+bool
+ValueObjectPrinter::PrintTypeIfNeeded ()
+{
+ 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 && 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 = options.m_show_types || (m_curr_depth == 0 && !options.m_flat_output);
+
+ if (show_type)
+ {
+ // Some ValueObjects don't have types (like registers sets). Only print
+ // the type if there is one to print
+ ConstString qualified_type_name(m_valobj->GetQualifiedTypeName());
+ if (qualified_type_name)
+ m_stream->Printf("(%s) ", qualified_type_name.GetCString());
+ else
+ show_type = false;
+ }
+ return show_type;
+}
+
+bool
+ValueObjectPrinter::PrintNameIfNeeded (bool show_type)
+{
+ if (options.m_flat_output)
+ {
+ // If we are showing types, also qualify the C++ base classes
+ const bool qualify_cxx_base_classes = show_type;
+ if (!options.m_hide_name)
+ {
+ m_valobj->GetExpressionPath(*m_stream, qualify_cxx_base_classes);
+ m_stream->PutCString(" =");
+ return true;
+ }
+ }
+ else if (!options.m_hide_name)
+ {
+ const char *name_cstr = GetRootNameForDisplay("");
+ m_stream->Printf ("%s =", name_cstr);
+ return true;
+ }
+ return false;
+}
+
+bool
+ValueObjectPrinter::CheckScopeIfNeeded ()
+{
+ if (options.m_scope_already_checked)
+ return true;
+ return m_valobj->IsInScope();
+}
+
+TypeSummaryImpl*
+ValueObjectPrinter::GetSummaryFormatter ()
+{
+ if (m_summary_formatter.second == false)
+ {
+ TypeSummaryImpl* entry = options.m_summary_sp ? options.m_summary_sp.get() : m_valobj->GetSummaryFormat().get();
+
+ if (options.m_omit_summary_depth > 0)
+ entry = NULL;
+ m_summary_formatter.first = entry;
+ m_summary_formatter.second = true;
+ }
+ return m_summary_formatter.first;
+}
+
+void
+ValueObjectPrinter::GetValueSummaryError (std::string& value,
+ std::string& summary,
+ std::string& error)
+{
+ if (options.m_format != eFormatDefault && options.m_format != m_valobj->GetFormat())
+ {
+ m_valobj->GetValueAsCString(options.m_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())
+ {
+ if (IsNil())
+ summary.assign("nil");
+ else if (options.m_omit_summary_depth == 0)
+ {
+ TypeSummaryImpl* entry = GetSummaryFormatter();
+ if (entry)
+ m_valobj->GetSummaryAsCString(entry, summary);
+ else
+ {
+ const char* sum_cstr = m_valobj->GetSummaryAsCString();
+ 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())
+ {
+ 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();
+ if (!IsNil() && !m_value.empty() && (entry == NULL || (entry->DoesPrintValue() || options.m_format != eFormatDefault) || m_summary.empty()) && !options.m_hide_value)
+ {
+ 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 (options.m_use_objc && !IsNil())
+ {
+ if (!options.m_hide_value || !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)
+ {
+ m_stream->Printf("%s\n", object_desc);
+ return true;
+ }
+ else if (value_printed == false && summary_printed == false)
+ return true;
+ else
+ return false;
+ }
+ }
+ return true;
+}
+
+bool
+ValueObjectPrinter::ShouldPrintChildren (bool is_failed_description,
+ uint32_t& curr_ptr_depth)
+{
+ const bool is_ref = IsRef ();
+ const bool is_ptr = IsPtr ();
+
+ if (is_failed_description || m_curr_depth < 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...
+ uint32_t curr_ptr_depth = m_ptr_depth;
+
+ 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;
+
+ else if (is_ref && m_curr_depth == 0)
+ {
+ // 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...
+ curr_ptr_depth = 1;
+ }
+
+ if (curr_ptr_depth == 0)
+ return false;
+ }
+
+ TypeSummaryImpl* entry = GetSummaryFormatter();
+
+ return (!entry || entry->DoesPrintChildren() || m_summary.empty());
+ }
+ return false;
+}
+
+ValueObject*
+ValueObjectPrinter::GetValueObjectForChildrenGeneration ()
+{
+ ValueObjectSP synth_valobj_sp = m_valobj->GetSyntheticValue (options.m_use_synthetic);
+ return (synth_valobj_sp ? synth_valobj_sp.get() : m_valobj);
+}
+
+void
+ValueObjectPrinter::PrintChildrenPreamble ()
+{
+ if (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,
+ uint32_t curr_ptr_depth)
+{
+ DumpValueObjectOptions child_options(options);
+ child_options.SetFormat(options.m_format).SetSummary().SetRootValueObjectName();
+ child_options.SetScopeChecked(true).SetHideName(options.m_hide_name).SetHideValue(options.m_hide_value)
+ .SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1 ? child_options.m_omit_summary_depth - 1 : 0);
+ if (child_sp.get())
+ {
+ ValueObjectPrinter child_printer(child_sp.get(),
+ m_stream,
+ child_options,
+ (IsPtr() || IsRef()) ? curr_ptr_depth - 1 : curr_ptr_depth,
+ m_curr_depth + 1);
+ child_printer.PrintValueObject();
+ }
+
+}
+
+uint32_t
+ValueObjectPrinter::GetMaxNumChildrenToPrint (bool& print_dotdotdot)
+{
+ ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
+
+ 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 && !options.m_ignore_cap)
+ {
+ print_dotdotdot = true;
+ return max_num_children;
+ }
+ }
+ return num_children;
+}
+
+void
+ValueObjectPrinter::PrintChildrenPostamble (bool print_dotdotdot)
+{
+ if (!options.m_flat_output)
+ {
+ if (print_dotdotdot)
+ {
+ m_valobj->GetTargetSP()->GetDebugger().GetCommandInterpreter().ChildrenTruncated();
+ m_stream->Indent("...\n");
+ }
+ m_stream->IndentLess();
+ m_stream->Indent("}\n");
+ }
+}
+
+void
+ValueObjectPrinter::PrintChildren (uint32_t curr_ptr_depth)
+{
+ ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
+
+ bool print_dotdotdot = false;
+ size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
+ if (num_children)
+ {
+ PrintChildrenPreamble ();
+
+ for (size_t idx=0; idx<num_children; ++idx)
+ {
+ ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
+ PrintChild (child_sp, curr_ptr_depth);
+ }
+
+ PrintChildrenPostamble (print_dotdotdot);
+ }
+ else if (IsAggregate())
+ {
+ // Aggregate, no children...
+ if (ShouldPrintValueObject())
+ m_stream->PutCString(" {}\n");
+ }
+ else
+ {
+ if (ShouldPrintValueObject())
+ m_stream->EOL();
+ }
+}
+
+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);
+
+ uint32_t curr_ptr_depth = m_ptr_depth;
+ bool print_children = ShouldPrintChildren (is_failed_description,curr_ptr_depth);
+
+ if (print_children)
+ {
+ PrintChildren (curr_ptr_depth);
+ }
+ else if (m_curr_depth >= options.m_max_depth && IsAggregate() && ShouldPrintValueObject())
+ {
+ m_stream->PutCString("{...}\n");
+ }
+}