[lldb] Add setting for max depth of value object printing (NFC)

[kastiglione]

Summary

This adds a setting (target.max-children-depth) that will provide a default value for the --depth flag used by expression and frame variable.

The new setting uses the same default that's currently fixed in source: UINT32_MAX.

This provides two purposes:

1. Allowing downstream forks to provide a customized default.
2. Allowing users to set their own default.

Following target.max-children-count, a warning is emitted when the max depth is reached. The warning lets users know which flags or settings they can customize. This warning is shown only when the limit is the default value.

rdar://87466495

[DavidSpickett]

Please include more context next time (https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface).

lldb/include/lldb/Interpreter/CommandInterpreter.h

499

ChildrenOmitted ? (and in general are we swapping terminology completely here because some uses have been changed some haven't)

511

For this printf the cmd_name is unused.

726

You're changing truncated to omitted elsewhere but not here. Unless there's a specific reason to keep some of them I'd go all in on "omitted" or change none of them.

(some of the function names might be baked into an API somewhere, I didn't check)

lldb/source/DataFormatters/ValueObjectPrinter.cpp

791

Help me understand here. If the max depth is the default value we tell the interpreter that we've hit max depth.

If it's not the default we don't but surely we have hit the max depth, just the max depth the user chose?

Seems like you'd want to signal the interpreter either way but clearly not because you felt the need to track if it was default. Is this because the interpreter uses ReachedMaxDepth for depths other than the one we're talking about here?

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

103

Should this only be set if parsing succeeds?

At least in the interactive mode I could do settings set ... <some rubbish> and it wouldn't change the value. Well, it would set it to UINT32_MAX again which doesn't seem like the user actually set something to me since we rejected their input.

lldb/source/Target/Target.cpp

4240

Given that this is a new function and the only caller provides a valid pointer, I'd make this (bool &is_default).

[kastiglione]

thanks for the review @DavidSpickett

lldb/include/lldb/Interpreter/CommandInterpreter.h

499

In the other place where I replaced "Truncate" with "Omit" it was to generalize the enum to be usable for the existing "truncate" and the new max depth cut off. Here, I felt that "truncated" could stay, as it seemed like a more specific term for this instance of omission. If other's don't see it that way then I will update this too.

511

Both warning texts do have a %s in them for the command name. I was thinking it would be better to inline the text, what do you think?

726

I missed this comment, thanks.

lldb/source/DataFormatters/ValueObjectPrinter.cpp

791

If the user has specified a max depth (either by flag or by a custom setting), then my assumption is they don't need to be reminded how to control the max depth. The warning, to my thinking, has emphasis on "here's how to adjust the limit", and not to tell you "the limit was reached". I'd like to think that seeing = { ... } in the output will be enough to say the limit was reached. A question here is: if a user has customized their setting, would they want to see the message every time? It seems lldb has a lot of one-time warnings, so now I wonder which warnings qualify for every-time.

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

103

good point

lldb/source/Target/Target.cpp

4240

agreed

[DavidSpickett]

lldb/include/lldb/Interpreter/CommandInterpreter.h

511

Doh, yes you're right. Without the context Phab is showing:

  const char *TruncationWarningText() {
    return "*** Some of your variables have more members than the debugger "
< "Context not available." >
           "the target.max-children-count setting.\n";
  }

But I see it in the source file.

Yes inling the strings makes sense if this is the only use.

[DavidSpickett]

lldb/include/lldb/Interpreter/CommandInterpreter.h

499

Fair enough.

You could read it either way I suppose. We have "omitted" some of the children vs we have "truncated" the list of children. Either is fine.

lldb/source/DataFormatters/ValueObjectPrinter.cpp

791

Got it. In fact you might be annoyed by the warning and go set this setting to specifically avoid it, I think it makes sense as you have it here.

Could you add a comment explaining that logic?

[DavidSpickett]

lldb/source/DataFormatters/ValueObjectPrinter.cpp

791

Tbf, I should have just read the commit msg properly "This warning is shown only when the limit is the default value." :)

A code comment is still a good addition.

[aprantl]

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

128

Can you add a = ...; initializer here?

lldb/include/lldb/Interpreter/CommandInterpreter.h

231

/// Tristate boolean to manage children
/// elision warnings.
enum ChildrenOmissionWarningStatus 
  {
    eNoOmission = 0,       ///< None omitted.
    eUnwarnedOmission = 1, ///< Omission, but have not notified.
    eWarnedOmission = 2    ///< Omission and notified.

529

Some of the displayed variables ...
Otherwise it sounds like we're blaming the user for having such terrible variables in their code ;-)

Is fields a better generic term for `members?

723

Can you doxygenify this comment while you're there?

lldb/source/Target/Target.cpp

4240

Should it return a pair<> or a one-off struct instead?

lldb/source/Target/TargetProperties.td

76

Should we use a slightly more reasonable default value (maybe 0xff) here?

[kastiglione]

lldb/source/Target/TargetProperties.td

76

My intention was to make this change NFC, which is how I arrived at 0xFFFFFFFF, it is the current default (basically unlimited).

I am not sure who would be effected by reducing the limit, and whether it would be a desirable or undesirable effect. A change to the default could be a separate diff.

In practice, I wonder if 0xFF is any different from 0XFFFFFFFF. In other words, how often do people reach a nesting depth of 255.

[aprantl]

lldb/source/Target/TargetProperties.td

76

My intention was to make this change NFC, which is how I arrived at 0xFFFFFFFF, it is the current default (basically unlimited).

That's perfectly valid reasoning! Thanks

[kastiglione]

Updated for code review.

[shafik]

lldb/include/lldb/Interpreter/CommandInterpreter.h

718

Why not use in class member initialization? It looks like they have default values. I am not sure why the rest of the values where not caught the other day when I ran clang-tidy.

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

180–183

My kingdom for structured bindings.

[kastiglione]

lldb/include/lldb/Interpreter/CommandInterpreter.h

718

I was following the convention within the file. What's the ideal change, initialize all in this change? Or initialize the two that I have edited?

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

180–183

soon, hopefully.

[kastiglione]

lldb/include/lldb/Interpreter/CommandInterpreter.h

718

I think it's best to leave these as is, and make a follow up change that uses member initialization for all of these.

[kastiglione]

Fixed: comment formatting; bool logic bug

[aprantl]

Few nitpicks inside otherwise I'm happy.

lldb/include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

51

Should this be with the other bools on line 45?

lldb/include/lldb/Target/Target.h

169

Doxygen comment to explain what the bool returns?

[DavidSpickett]

All my comments were addressed.

[kastiglione]

lldb/include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

51

It wasn't there because of std::tie can't bind to a bit field value. I've moved this bool into the bitfield and got rid of the std::tie.

[kastiglione]

Addresses Adrian's feedback.

[kastiglione]

Fixed/improved docstring

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

public:
 
   DumpValueObjectOptions();
 
   DumpValueObjectOptions(ValueObject &valobj);
 
   DumpValueObjectOptions &
   SetMaximumPointerDepth(PointerDepth depth = {PointerDepth::Mode::Never, 0});
 
-  DumpValueObjectOptions &SetMaximumDepth(uint32_t depth = 0);
+  DumpValueObjectOptions &SetMaximumDepth(uint32_t depth, bool is_default);
 
   DumpValueObjectOptions &SetDeclPrintingHelper(DeclPrintingHelper helper);
 
   DumpValueObjectOptions &SetShowTypes(bool show = false);
 
   DumpValueObjectOptions &SetShowLocation(bool show = false);
 
   DumpValueObjectOptions &SetUseObjectiveC(bool use = false);
public:
   DumpValueObjectOptions &SetRevealEmptyAggregates(bool reveal = true);
 
   DumpValueObjectOptions &SetElementCount(uint32_t element_count = 0);
 
   DumpValueObjectOptions &
   SetPointerAsArray(const PointerAsArraySettings &ptr_array);
 
   uint32_t m_max_depth = UINT32_MAX;
+  bool m_max_depth_is_default = true;
   lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
   uint32_t m_omit_summary_depth = 0;
   lldb::Format m_format = lldb::eFormatDefault;
   lldb::TypeSummaryImplSP m_summary_sp;
   std::string m_root_valobj_name;
   lldb::LanguageType m_varformat_language = lldb::eLanguageTypeUnknown;
   PointerDepth m_max_ptr_depth;
   DeclPrintingHelper m_decl_printing_helper;

lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

protected:
   void
   PrintChildren(bool value_printed, bool summary_printed,
                 const DumpValueObjectOptions::PointerDepth &curr_ptr_depth);
 
   void PrintChildrenIfNeeded(bool value_printed, bool summary_printed);
 
   bool PrintChildrenOneLiner(bool hide_names);
 
+  bool HasReachedMaximumDepth();
+
 private:
   ValueObject *m_orig_valobj;
   ValueObject *m_valobj;
   Stream *m_stream;
   DumpValueObjectOptions m_options;
   Flags m_type_flags;
   CompilerType m_compiler_type;
   DumpValueObjectOptions::PointerDepth m_ptr_depth;

lldb/include/lldb/Interpreter/CommandInterpreter.h

public:
   enum {
     eBroadcastBitThreadShouldExit = (1 << 0),
     eBroadcastBitResetPrompt = (1 << 1),
     eBroadcastBitQuitCommandReceived = (1 << 2), // User entered quit
     eBroadcastBitAsynchronousOutputData = (1 << 3),
     eBroadcastBitAsynchronousErrorData = (1 << 4)
   };
 
-  enum ChildrenTruncatedWarningStatus // tristate boolean to manage children
-                                      // truncation warning
-  { eNoTruncation = 0,                // never truncated
-    eUnwarnedTruncation = 1,          // truncated but did not notify
-    eWarnedTruncation = 2             // truncated and notified
+  /// Tristate boolean to manage children omission warnings.
+  enum ChildrenOmissionWarningStatus {
+    eNoOmission = 0,       ///< No children were omitted.
+    eUnwarnedOmission = 1, ///< Children omitted, and not yet notified.
+    eWarnedOmission = 2    ///< Children omitted and notified.
   };
 
   enum CommandTypes {
     eCommandTypesBuiltin = 0x0001, //< native commands such as "frame"
     eCommandTypesUserDef = 0x0002, //< scripted commands
     eCommandTypesUserMW  = 0x0004, //< multiword commands (command containers)
     eCommandTypesAliases = 0x0008, //< aliases such as "po"
     eCommandTypesHidden  = 0x0010, //< commands prefixed with an underscore
     eCommandTypesAllThem = 0xFFFF  //< all commands
public:
 
   bool SetBatchCommandMode(bool value) {
     const bool old_value = m_batch_command_mode;
     m_batch_command_mode = value;
     return old_value;
   }
 
   void ChildrenTruncated() {
-    if (m_truncation_warning == eNoTruncation)
-      m_truncation_warning = eUnwarnedTruncation;
+    if (m_truncation_warning == eNoOmission)
+      m_truncation_warning = eUnwarnedOmission;
   }
 
-  bool TruncationWarningNecessary() {
-    return (m_truncation_warning == eUnwarnedTruncation);
+  void SetReachedMaximumDepth() {
+    if (m_max_depth_warning == eNoOmission)
+      m_max_depth_warning = eUnwarnedOmission;
+  }
+
+  void PrintWarningsIfNecessary(Stream &s, const std::string &cmd_name) {
+    if (m_truncation_warning == eUnwarnedOmission) {
+      s.Printf("*** Some of the displayed variables have more members than the "
+               "debugger will show by default. To show all of them, you can "
+               "either use the --show-all-children option to %s or raise the "
+               "limit by changing the target.max-children-count setting.\n",
+               cmd_name.c_str());
+      m_truncation_warning = eWarnedOmission;
+    }
+
+    if (m_max_depth_warning == eUnwarnedOmission) {
+      s.Printf("*** Some of the displayed variables have a greater depth of "
+               "members than the debugger will show by default. To increase "
+               "the limit, use the --depth option to %s, or raise the limit by "
+               "changing the target.max-children-depth setting.\n",
+               cmd_name.c_str());
+      m_max_depth_warning = eWarnedOmission;
     }
-
-  void TruncationWarningGiven() { m_truncation_warning = eWarnedTruncation; }
-
-  const char *TruncationWarningText() {
-    return "*** Some of your variables have more members than the debugger "
-           "will show by default. To show all of them, you can either use the "
-           "--show-all-children option to %s or raise the limit by changing "
-           "the target.max-children-count setting.\n";
   }
 
   CommandHistory &GetCommandHistory() { return m_command_history; }
 
   bool IsActive();
 
   CommandInterpreterRunResult
   RunCommandInterpreter(CommandInterpreterRunOptions &options);
 
   void GetLLDBCommandsFromIOHandler(const char *prompt,
                                     IOHandlerDelegate &delegate,
                                     void *baton = nullptr);
private:
   CommandObject::CommandMap
       m_user_mw_dict; // Stores user-defined multiword commands
   CommandHistory m_command_history;
   std::string m_repeat_command; // Stores the command that will be executed for
                                 // an empty command string.
   lldb::IOHandlerSP m_command_io_handler_sp;
   char m_comment_char;
   bool m_batch_command_mode;
-  ChildrenTruncatedWarningStatus m_truncation_warning; // Whether we truncated
-                                                       // children and whether
-                                                       // the user has been told
+  /// Whether we truncated a value's list of children and whether the user has
+  /// been told.
+  ChildrenOmissionWarningStatus m_truncation_warning;
+  /// Whether we reached the maximum child nesting depth and whether the user
+  /// has been told.
+  ChildrenOmissionWarningStatus m_max_depth_warning;
 
   // FIXME: Stop using this to control adding to the history and then replace
   // this with m_command_source_dirs.size().
   uint32_t m_command_source_depth;
   /// A stack of directory paths. When not empty, the last one is the directory
   /// of the file that's currently sourced.
   std::vector<FileSpec> m_command_source_dirs;
   std::vector<uint32_t> m_command_source_flags;
   CommandInterpreterRunResult m_result;
 
   // The exit code the user has requested when calling the 'quit' command.
   // No value means the user hasn't set a custom exit code so far.
   llvm::Optional<int> m_quit_exit_code;

lldb/include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

public:
 
   DumpValueObjectOptions GetAsDumpOptions(
       LanguageRuntimeDescriptionDisplayVerbosity lang_descr_verbosity =
           eLanguageRuntimeDescriptionDisplayVerbosityFull,
       lldb::Format format = lldb::eFormatDefault,
       lldb::TypeSummaryImplSP summary_sp = lldb::TypeSummaryImplSP());
 
   bool show_types : 1, show_location : 1, flat_output : 1, use_objc : 1,
-      use_synth : 1, be_raw : 1, ignore_cap : 1, run_validator : 1;
+      use_synth : 1, be_raw : 1, ignore_cap : 1, run_validator : 1,
+      max_depth_is_default : 1;
 
   uint32_t no_summary_depth;
   uint32_t max_depth;
   uint32_t ptr_depth;
   uint32_t elem_count;
   lldb::DynamicValueType use_dynamic;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPVALUEOBJECTDISPLAY_H

lldb/include/lldb/Interpreter/OptionValueProperties.h

public:
   const RegularExpression *
   GetPropertyAtIndexAsOptionValueRegex(const ExecutionContext *exe_ctx,
                                        uint32_t idx) const;
 
   OptionValueSInt64 *
   GetPropertyAtIndexAsOptionValueSInt64(const ExecutionContext *exe_ctx,
                                         uint32_t idx) const;
 
+  OptionValueUInt64 *
+  GetPropertyAtIndexAsOptionValueUInt64(const ExecutionContext *exe_ctx,
+                                        uint32_t idx) const;
+
   int64_t GetPropertyAtIndexAsSInt64(const ExecutionContext *exe_ctx,
                                      uint32_t idx, int64_t fail_value) const;
 
   bool SetPropertyAtIndexAsSInt64(const ExecutionContext *exe_ctx, uint32_t idx,
                                   int64_t new_value);
 
   uint64_t GetPropertyAtIndexAsUInt64(const ExecutionContext *exe_ctx,
                                       uint32_t idx, uint64_t fail_value) const;

lldb/include/lldb/Target/Target.h

public:
   FileSpec GetSaveJITObjectsDir() const;
   
   bool GetEnableSyntheticValue() const;
 
   uint32_t GetMaxZeroPaddingInFloatFormat() const;
 
   uint32_t GetMaximumNumberOfChildrenToDisplay() const;
 
+  /// Get the max depth value, augmented with a bool to indicate whether the
+  /// depth is the default.
+  ///
+  /// When the user has customized the max depth, the bool will be false.
+  ///
+  /// \returns the max depth, and true if the max depth is the system default,
+  /// otherwise false.
+  std::pair<uint32_t, bool> GetMaximumDepthOfChildrenToDisplay() const;
+
   uint32_t GetMaximumSizeOfStringSummary() const;
 
   uint32_t GetMaximumMemReadSize() const;
 
   FileSpec GetStandardInputPath() const;
   FileSpec GetStandardErrorPath() const;
   FileSpec GetStandardOutputPath() const;
 

lldb/source/Commands/CommandObjectFrame.cpp

if (m_option_variable.show_recognized_args) {
                 rec_value_sp->GetPreferredDisplayLanguage());
             options.SetRootValueObjectName(rec_value_sp->GetName().AsCString());
             rec_value_sp->Dump(result.GetOutputStream(), options);
           }
         }
       }
     }
 
-    if (m_interpreter.TruncationWarningNecessary()) {
-      result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(),
-                                      m_cmd_name.c_str());
-      m_interpreter.TruncationWarningGiven();
-    }
+    m_interpreter.PrintWarningsIfNecessary(result.GetOutputStream(),
+                                           m_cmd_name);
 
     // Increment statistics.
     bool res = result.Succeeded();
     TargetStats &target_stats = GetSelectedOrDummyTarget().GetStatistics();
     if (res)
       target_stats.GetFrameVariableStats().NotifySuccess();
     else
       target_stats.GetFrameVariableStats().NotifyFailure();

lldb/source/Commands/CommandObjectTarget.cpp

if (argc > 0) {
                 DumpGlobalVariableList(m_exe_ctx, sc, variable_list, s);
               }
             }
           }
         }
       }
     }
 
-    if (m_interpreter.TruncationWarningNecessary()) {
-      result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(),
-                                      m_cmd_name.c_str());
-      m_interpreter.TruncationWarningGiven();
-    }
+    m_interpreter.PrintWarningsIfNecessary(result.GetOutputStream(),
+                                           m_cmd_name);
 
     return result.Succeeded();
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupVariable m_option_variable;
   OptionGroupFormat m_option_format;
   OptionGroupFileList m_option_compile_units;

lldb/source/DataFormatters/DumpValueObjectOptions.cpp

 
 DumpValueObjectOptions &
 DumpValueObjectOptions::SetMaximumPointerDepth(PointerDepth depth) {
   m_max_ptr_depth = depth;
   return *this;
 }
 
 DumpValueObjectOptions &
-DumpValueObjectOptions::SetMaximumDepth(uint32_t depth) {
+DumpValueObjectOptions::SetMaximumDepth(uint32_t depth, bool is_default) {
   m_max_depth = depth;
+  m_max_depth_is_default = is_default;
   return *this;
 }
 
 DumpValueObjectOptions &
 DumpValueObjectOptions::SetDeclPrintingHelper(DeclPrintingHelper helper) {
   m_decl_printing_helper = helper;
   return *this;
 }

lldb/source/DataFormatters/ValueObjectPrinter.cpp

bool ValueObjectPrinter::ShouldPrintChildren(
   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) {
+  if (is_failed_description || !HasReachedMaximumDepth()) {
     // 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) {
void ValueObjectPrinter::PrintChildrenIfNeeded(bool value_printed,
 
   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() &&
+  } else if (HasReachedMaximumDepth() && IsAggregate() &&
              ShouldPrintValueObject()) {
     m_stream->PutCString("{...}\n");
+    // The maximum child depth has been reached. If `m_max_depth` is the default
+    // (i.e. the user has _not_ customized it), then lldb presents a warning to
+    // the user. The warning tells the user that the limit has been reached, but
+    // more importantly tells them how to expand the limit if desired.
+    if (m_options.m_max_depth_is_default)
+      m_valobj->GetTargetSP()
+          ->GetDebugger()
+          .GetCommandInterpreter()
+          .SetReachedMaximumDepth();
   } else
     m_stream->EOL();
 }
+
+bool ValueObjectPrinter::HasReachedMaximumDepth() {
+  return m_curr_depth >= m_options.m_max_depth;
+}

lldb/source/Interpreter/CommandInterpreter.cpp

CommandInterpreter::CommandInterpreter(Debugger &debugger,
     : Broadcaster(debugger.GetBroadcasterManager(),
                   CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
       Properties(OptionValuePropertiesSP(
           new OptionValueProperties(ConstString("interpreter")))),
       IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
       m_debugger(debugger), m_synchronous_execution(true),
       m_skip_lldbinit_files(false), m_skip_app_init_files(false),
       m_comment_char('#'), m_batch_command_mode(false),
-      m_truncation_warning(eNoTruncation), m_command_source_depth(0) {
+      m_truncation_warning(eNoOmission), m_max_depth_warning(eNoOmission),
+      m_command_source_depth(0) {
   SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
   SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
   SetEventName(eBroadcastBitQuitCommandReceived, "quit");
   SetSynchronous(synchronous_execution);
   CheckInWithManager();
   m_collection_sp->Initialize(g_interpreter_properties);
 }
 

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

Status OptionGroupValueObjectDisplay::SetOptionValue(
   case 'R':
     be_raw = true;
     break;
   case 'A':
     ignore_cap = true;
     break;
 
   case 'D':
     if (option_arg.getAsInteger(0, max_depth)) {
       max_depth = UINT32_MAX;
       error.SetErrorStringWithFormat("invalid max depth '%s'",
                                      option_arg.str().c_str());
+    } else {
+      max_depth_is_default = false;
     }
     break;
 
   case 'Z':
     if (option_arg.getAsInteger(0, elem_count)) {
       elem_count = UINT32_MAX;
       error.SetErrorStringWithFormat("invalid element count '%s'",
                                      option_arg.str().c_str());
void OptionGroupValueObjectDisplay::OptionParsingStarting(
     ExecutionContext *execution_context) {
   // If these defaults change, be sure to modify AnyOptionWasSet().
   show_types = false;
   no_summary_depth = 0;
   show_location = false;
   flat_output = false;
   use_objc = false;
   max_depth = UINT32_MAX;
+  max_depth_is_default = true;
   ptr_depth = 0;
   elem_count = 0;
   use_synth = true;
   be_raw = false;
   ignore_cap = false;
   run_validator = false;
 
   TargetSP target_sp =
       execution_context ? execution_context->GetTargetSP() : TargetSP();
-  if (target_sp)
+  if (target_sp) {
     use_dynamic = target_sp->GetPreferDynamicValue();
-  else {
+    auto max_depth_config = target_sp->GetMaximumDepthOfChildrenToDisplay();
+    max_depth = std::get<uint32_t>(max_depth_config);
+    max_depth_is_default = std::get<bool>(max_depth_config);
+  } else {
     // If we don't have any targets, then dynamic values won't do us much good.
     use_dynamic = lldb::eNoDynamicValues;
   }
 }
 
 DumpValueObjectOptions OptionGroupValueObjectDisplay::GetAsDumpOptions(
     LanguageRuntimeDescriptionDisplayVerbosity lang_descr_verbosity,
     lldb::Format format, lldb::TypeSummaryImplSP summary_sp) {
   DumpValueObjectOptions options;
   options.SetMaximumPointerDepth(
       {DumpValueObjectOptions::PointerDepth::Mode::Always, ptr_depth});
   if (use_objc)
     options.SetShowSummary(false);
   else
     options.SetOmitSummaryDepth(no_summary_depth);
-  options.SetMaximumDepth(max_depth)
+  options.SetMaximumDepth(max_depth, max_depth_is_default)
       .SetShowTypes(show_types)
       .SetShowLocation(show_location)
       .SetUseObjectiveC(use_objc)
       .SetUseDynamicType(use_dynamic)
       .SetUseSyntheticValue(use_synth)
       .SetFlatOutput(flat_output)
       .SetIgnoreCap(ignore_cap)
       .SetFormat(format)

lldb/source/Interpreter/OptionValueProperties.cpp

OptionValueSInt64 *OptionValueProperties::GetPropertyAtIndexAsOptionValueSInt64(
   if (property) {
     OptionValue *value = property->GetValue().get();
     if (value)
       return value->GetAsSInt64();
   }
   return nullptr;
 }
 
+OptionValueUInt64 *OptionValueProperties::GetPropertyAtIndexAsOptionValueUInt64(
+    const ExecutionContext *exe_ctx, uint32_t idx) const {
+  const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
+  if (property) {
+    OptionValue *value = property->GetValue().get();
+    if (value)
+      return value->GetAsUInt64();
+  }
+  return nullptr;
+}
+
 int64_t OptionValueProperties::GetPropertyAtIndexAsSInt64(
     const ExecutionContext *exe_ctx, uint32_t idx, int64_t fail_value) const {
   const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
   if (property) {
     OptionValue *value = property->GetValue().get();
     if (value)
       return value->GetSInt64Value(fail_value);
   }

lldb/source/Target/Target.cpp

 }
 
 uint32_t TargetProperties::GetMaximumNumberOfChildrenToDisplay() const {
   const uint32_t idx = ePropertyMaxChildrenCount;
   return m_collection_sp->GetPropertyAtIndexAsSInt64(
       nullptr, idx, g_target_properties[idx].default_uint_value);
 }
 
+std::pair<uint32_t, bool>
+TargetProperties::GetMaximumDepthOfChildrenToDisplay() const {
+  const uint32_t idx = ePropertyMaxChildrenDepth;
+  auto *option_value =
+      m_collection_sp->GetPropertyAtIndexAsOptionValueUInt64(nullptr, idx);
+  bool is_default = !option_value->OptionWasSet();
+  return {option_value->GetCurrentValue(), is_default};
+}
+
 uint32_t TargetProperties::GetMaximumSizeOfStringSummary() const {
   const uint32_t idx = ePropertyMaxSummaryLength;
   return m_collection_sp->GetPropertyAtIndexAsSInt64(
       nullptr, idx, g_target_properties[idx].default_uint_value);
 }
 
 uint32_t TargetProperties::GetMaximumMemReadSize() const {
   const uint32_t idx = ePropertyMaxMemReadSize;

lldb/source/Target/TargetProperties.td

def SaveObjectsDir: Property<"save-jit-objects-dir", "FileSpec">,
     DefaultStringValue<"">,
     Desc<"If specified, the directory to save intermediate object files generated by the LLVM JIT">;
   def MaxZeroPaddingInFloatFormat: Property<"max-zero-padding-in-float-format", "UInt64">,
     DefaultUnsignedValue<6>,
     Desc<"The maximum number of zeroes to insert when displaying a very small float before falling back to scientific notation.">;
   def MaxChildrenCount: Property<"max-children-count", "SInt64">,
     DefaultUnsignedValue<256>,
     Desc<"Maximum number of children to expand in any level of depth.">;
+  def MaxChildrenDepth: Property<"max-children-depth", "UInt64">,
+    DefaultUnsignedValue<0xFFFFFFFF>,
+    Desc<"Maximum depth to expand children.">;
   def MaxSummaryLength: Property<"max-string-summary-length", "SInt64">,
     DefaultUnsignedValue<1024>,
     Desc<"Maximum number of characters to show when using %s in summary strings.">;
   def MaxMemReadSize: Property<"max-memory-read-size", "SInt64">,
     DefaultUnsignedValue<1024>,
     Desc<"Maximum number of bytes that 'memory read' will fetch before --force must be specified.">;
   def BreakpointUseAvoidList: Property<"breakpoints-use-platform-avoid-list", "Boolean">,
     DefaultTrue,