[SBValue] Add a method GetNumChildren(uint32_t max)

[sivachandra]

Summary

Along with this, support for an optional argument to the "num_children"
method of a Python synthetic child provider has also been added. These have
been added with the following use case in mind:

Synthetic child providers currently have a method "has_children" and
"num_children". While the former is good enough to know if there are
children, it does not give any insight into how many children there are.
Though the latter serves this purpose, calculating the number for children
of a data structure could be an O(N) operation if the data structure has N
children. The new method added in this change provide a middle ground.
One can call GetNumChildren(K) to know if a child exists at an index K
which can be as large as the callers tolerance can be. If the caller wants
to know about children beyond K, it can make an other call with 2K. If the
synthetic child provider maintains state about it counting till K
previosly, then the next call is only an O(K) operation. Infact, all
calls made progressively with steps of K will be O(K) operations.

[sivachandra]

If the general idea in this patch is OK, I will update it with tests.

[granata.enrico]

What do you plan to use this has_child_at_index call for?

My concern is that it adds complication to the synthetic child provider interface. Yes, I understand it is optional, but it seems like yet another thing in the "any children?" realm that I would rather much avoid if possible. Which is why my question. Let's start from the use case and see if we can come up with anything else that could cover it.

[sivachandra]

As I mentioned in the first post, this is the use case:

Synthetic child providers currently have a method "has_children" and
"get_num_children". While the former is good enough to know if there are
children, it does not give any insight into how many children there are.
Though the latter serves this purpose, calculating the number for children
of a data structure could be an O(N) operation if the data structure has N
children. The new methods added in this change provide a middle ground.
One can call HasChildAtIndex to know if a child exists at an index K which
can be as large as the callers tolerance can be. If the caller wants to
know about children beyond K, it can make an other call with 2K. If the
synthetic child provider maintains state about it counting till K
previosly, then the next call is only an O(K) operation. Infact, all
calls made progressively with steps of K will be O(K) operations.

[granata.enrico]

Is it possible to ask for concrete examples?

As in, for example, do you plan to change ValueObjectPrinter to use this API in some way?
Or do you have any specific synthetic providers that you would like to use this API in?

[sivachandra]

Yes, we would like to use this is specific synthetic providers. It will not be used by any part of LLDB internally.

[granata.enrico]

If so, why do you need this to be exposed as a call that LLDB knows about?

You are free to provide any methods you want in your synthetic child providers. Adding them to the interface as this patch does is only necessary if you want LLDB to use the new methods as part of its interaction with the child provider.

[sivachandra]

Ah, we want this exposed in the SBValue API. What I mean't in the earlier message was that no other part of LLDB will functionally depend/lookup/expect this "feature".

[granata.enrico]

So, if I understand this correctly, this HasChildAtIndex() API returns a three-state int:

1 == yes I do
0 == no I do not
-1 == maybe, can't tell

When would you ever run into the -1 case? It seems you're mostly using it as an invalid marker. Would 0 not be a better choice for those invalid cases? Then you could just use a boolean which seems a better answer for an inherently yes/no question (invalid objects do not have a child at index for any index, do they?)

Also, if you're only using this from inside a synthetic child provider, why does it need to be in SBValue? Or is your argument that you want to write scripts against LLDB that use this feature?

Truth be told, I am not particularly excited about this feature, and the fact that this seems to be introduced in a vacuum does nothing to assuage my original concern that is is a potentially avoidable complication to the model.

[clayborg]

I would almost rather change the GetNumChildren() to take a "max" param:

class SBValue
{
     uint32_t
     GetNumChildren ();
     uint32_t
     GetNumChildren (uint32_t max = UINT32_MAX);
};

We need to keep the other one so that our public API still has the old call, but the second version could limit the number of children to verify to at most "max".

[sivachandra]

I did consider the option of adding a new method GetNumChildren (uint32_t max = UINT32_MAX). This if fine from SBValue point of view. But from a the scripted synthetic provider point of view, I am not sure there is an easy/clean way of checking whether the num_children method takes the max cap argument. Are you suggesting that we have different method like "num_children_with_cap"?

[granata.enrico]

One alternative would be to have the num_children method on the synthetic provider itself be able to take an optional argument that is the max_count. That is, instead of defining

def num_children(self):
  ..

You would instead define

def num_children(self, max_count):
  ..

Of course, you would need to continue supporting both possible signatures in order to maintain compatibility with existing formatters. But we do have some support for that. If you look at LLDBSwigPythonCallCommand:

PyCallable::argc argc = pfunc.GetNumArguments();
if (argc.num_args == 5 || argc.varargs == true)
    pvalue = pfunc(debugger_sb, args, exe_ctx_sb, &cmd_retobj_sb, session_dict = FindSessionDictionary(session_dictionary_name));
else
    pvalue = pfunc(debugger_sb, args, &cmd_retobj_sb, session_dict = FindSessionDictionary(session_dictionary_name));

num_children could start doing something similar for 1 vs. 2 arguments

[sivachandra]

Ah, I did not notice PyCallable::GetNumArguments before you drew my attention to it. It seems to be using internals of PyCodeObject. When I said "no easy/clean way", I was talking about avoiding such a usage. If that is acceptable, I am fine with it. I will modify this patch to add SBValue::GetNumArguments(uint32 max=UINT32_MAX).

[sivachandra]

I did this experiment before setting off:

class A
{
public:
  int method();
  int method(int a = 10);
};

int
A::method()
{
  return 10;
}

int
A::method(int a)
{
  return a + 10;
}

int
main()
{
  A a;
  return a.method();
}

The invocation a.method() is ambiguous:

$> clang++-3.5 -g methods.cc 
methods.cc:25:12: error: call to member function 'method' is ambiguous
  return a.method();
         ~~^~~~~~
methods.cc:10:4: note: candidate function
A::method()
   ^
methods.cc:16:4: note: candidate function
A::method(int a)
   ^
1 error generated.

So, what is wrong if I just add SBValue::GetNumChildren(int max) without a default argument?

[clayborg]

For the public API you will need both and not have a default arg.

[labath]

Not really my area, but couldn't the needed functionality be implemented on top of GetChildAtIndex(). I mean, if GetChildAtIndex(50) returns a valid SBValue, then the container has at least 50 elements, right?
Then HasAtLeastNChildren(n) == GetChildAtIndex(n).IsValid() and we don't need to add anything to the public API. Or am I missing something here... (?)

[sivachandra]

There could be an error reading the k-th element for k < n.In which case, we will wrongly conclude that there are only k-1 elements.

[labath]

How big of an error does it have to be for that to happen? Is that something we would consider an "lldb bug"/"data formatter bug" or it can be caused by something out of our control, like missing debug info on one of the children?

[sivachandra]

When such an error occurs, it is unlikely to be an lldb bug, or data-formatter bug. One can come up with a data structure for which reading a child element would require complete debug info, but reading the # of child elements need not require complete debug info (there could be an instance variable storing the size). Another could be that a child is improperly initialized but the data structure itself is properly initialized.

[sivachandra]

Address comments.

[sivachandra]

Pinging to ensure that it did not get lost in the title change.

[labath]

When such an error occurs, it is unlikely to be an lldb bug, or data-formatter bug. One can come up with a data structure for which reading a child element would require complete debug info, but reading the # of child elements need not require complete debug info (there could be an instance variable storing the size). Another could be that a child is improperly initialized but the data structure itself is properly initialized.

Ok, that makes sense. No objections from my side.

source/API/SBValue.cpp

1275

You can replace this by return GetNumChildren(UINT32_MAX);

[sivachandra]

Add tests.

[clayborg]

Accepted as long as Enrico is OK with this.

[granata.enrico]

Looks fine

include/lldb/API/SBValue.h

#endif
     MightHaveChildren ();
     
     bool
     IsRuntimeSupportValue ();
 
     uint32_t
     GetNumChildren ();
 
+    uint32_t
+    GetNumChildren (uint32_t max);
+
     void *
     GetOpaqueType();
 
     lldb::SBTarget
     GetTarget();
     
     lldb::SBProcess
     GetProcess();

include/lldb/Core/ValueObject.h

//        SetContext (ExecutionContextScope *exe_scope);
     
     virtual lldb::ValueObjectSP
     GetChildMemberWithName (const ConstString &name, bool can_create);
 
     virtual size_t
     GetIndexOfChildWithName (const ConstString &name);
 
     size_t
-    GetNumChildren ();
+    GetNumChildren (uint32_t max=UINT32_MAX);
 
     const Value &
     GetValue() const;
 
     Value &
     GetValue();
 
     virtual bool
protected:
     
     // Should only be called by ValueObject::GetChildAtIndex()
     // Returns a ValueObject managed by this ValueObject's manager.
     virtual ValueObject *
     CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
 
     // Should only be called by ValueObject::GetNumChildren()
     virtual size_t
-    CalculateNumChildren() = 0;
+    CalculateNumChildren(uint32_t max=UINT32_MAX) = 0;
 
     void
     SetNumChildren (size_t num_children);
 
     void
     SetValueDidChange (bool value_changed);
 
     void

include/lldb/Core/ValueObjectCast.h

Create (ValueObject &parent,
             const CompilerType &cast_type);
 
     ~ValueObjectCast() override;
     
     uint64_t
     GetByteSize() override;
     
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
     
     lldb::ValueType
     GetValueType() const override;
     
     bool
     IsInScope() override;
     
     ValueObject *

include/lldb/Core/ValueObjectChild.h

public:
     {
         return m_bitfield_bit_offset;
     }
 
     lldb::ValueType
     GetValueType() const override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     ConstString
     GetTypeName() override;
 
     ConstString
     GetQualifiedTypeName() override;
     
     ConstString

include/lldb/Core/ValueObjectConstResult.h

public:
 
     uint64_t
     GetByteSize() override;
 
     lldb::ValueType
     GetValueType() const override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     ConstString
     GetTypeName() override;
 
     ConstString
     GetDisplayTypeName() override;
     
     bool

include/lldb/Core/ValueObjectDynamicValue.h

public:
 
     ConstString
     GetQualifiedTypeName() override;
 
     ConstString
     GetDisplayTypeName() override;
     
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     lldb::ValueType
     GetValueType() const override;
 
     bool
     IsInScope() override;
     
     bool

include/lldb/Core/ValueObjectMemory.h

public:
 
     ConstString
     GetTypeName() override;
 
     ConstString
     GetDisplayTypeName() override;
     
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     lldb::ValueType
     GetValueType() const override;
 
     bool
     IsInScope() override;
 
     lldb::ModuleSP

include/lldb/Core/ValueObjectRegister.h

public:
     
     ConstString
     GetQualifiedTypeName() override;
     
     ConstString
     GetDisplayTypeName() override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     ValueObject *
     CreateChildAtIndex(size_t idx, bool synthetic_array_member, int32_t synthetic_index) override;
 
 protected:
     bool
     UpdateValue() override;
     
public:
 
     ConstString
     GetTypeName() override;
     
     ConstString
     GetQualifiedTypeName() override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     ValueObject *
     CreateChildAtIndex(size_t idx, bool synthetic_array_member, int32_t synthetic_index) override;
     
     lldb::ValueObjectSP
     GetChildMemberWithName(const ConstString &name, bool can_create) override;
 
     size_t
public:
     {
         return lldb::eValueTypeRegister;
     }
 
     ConstString
     GetTypeName() override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
     
     bool
     SetValueFromCString(const char *value_str, Error& error) override;
     
     bool
     SetData(DataExtractor &data, Error &error) override;
 
     bool

include/lldb/Core/ValueObjectSyntheticFilter.h

public:
     
     ConstString
     GetDisplayTypeName() override;
 
     bool
     MightHaveChildren() override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     lldb::ValueType
     GetValueType() const override;
     
     lldb::ValueObjectSP
     GetChildAtIndex(size_t idx, bool can_create) override;
     
     lldb::ValueObjectSP

include/lldb/Core/ValueObjectVariable.h

public:
 
     ConstString
     GetQualifiedTypeName() override;
     
     ConstString
     GetDisplayTypeName() override;
 
     size_t
-    CalculateNumChildren() override;
+    CalculateNumChildren(uint32_t max) override;
 
     lldb::ValueType
     GetValueType() const override;
 
     bool
     IsInScope() override;
 
     lldb::ModuleSP

include/lldb/DataFormatters/TypeSynthetic.h

public:
         m_backend(backend),
         m_valid(true)
         {}
         
         virtual
         ~SyntheticChildrenFrontEnd ()
         {
         }
-        
         virtual size_t
         CalculateNumChildren () = 0;
-        
+        virtual size_t
+        CalculateNumChildren (uint32_t max)
+        {
+            auto count = CalculateNumChildren ();
+            return count <= max ? count : max;
+        }
+        
         virtual lldb::ValueObjectSP
         GetChildAtIndex (size_t idx) = 0;
-        
         virtual size_t
         GetIndexOfChildWithName (const ConstString &name) = 0;
         
         // this function is assumed to always succeed and it if fails, the front-end should know to deal
         // with it in the correct way (most probably, by refusing to return any children)
         // the return value of Update() should actually be interpreted as "ValueObjectSyntheticFilter cache is good/bad"
         // if =true, ValueObjectSyntheticFilter is allowed to use the children it fetched previously and cached
         // if =false, ValueObjectSyntheticFilter must throw away its cache, and query again for children
public:
             
             lldb::ValueObjectSP
             GetChildAtIndex(size_t idx) override
             {
                 if (idx >= filter->GetCount())
                     return lldb::ValueObjectSP();
                 return m_backend.GetSyntheticExpressionPathChild(filter->GetExpressionPathAtIndex(idx), true);
             }
-            
             bool
             Update() override { return false; }
             
             bool
             MightHaveChildren() override
             {
                 return filter->GetCount() > 0;
             }
public:
             
             FrontEnd (std::string pclass,
                       ValueObject &backend);
             
             bool
             IsValid ();
             
             ~FrontEnd() override;
-            
             size_t
             CalculateNumChildren() override;
-            
+            size_t
+            CalculateNumChildren(uint32_t max) override;
+            
             lldb::ValueObjectSP
             GetChildAtIndex(size_t idx) override;
-            
             bool
             Update() override;
             
             bool
             MightHaveChildren() override;
             
             size_t
             GetIndexOfChildWithName(const ConstString &name) override;

include/lldb/Interpreter/ScriptInterpreter.h

public:
     
     virtual void
     Clear ()
     {
         // Clean up any ref counts to SBObjects that might be in global variables
     }
 
     virtual size_t
-    CalculateNumChildren(const StructuredData::ObjectSP &implementor)
+    CalculateNumChildren(const StructuredData::ObjectSP &implementor, uint32_t max)
     {
         return 0;
     }
 
     virtual lldb::ValueObjectSP
     GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx)
     {
         return lldb::ValueObjectSP();

scripts/Python/python-wrapper.swig

struct argc {
         size_t num_args;
         bool varargs : 1;
         bool kwargs : 1;
     };
 
     argc
     GetNumArguments ()
     {
-        if (m_callable && PyFunction_Check(m_callable))
+        PyObject *py_func_obj = NULL;
+        if (m_callable)
         {
-            PyCodeObject* code = (PyCodeObject*)PyFunction_GET_CODE(m_callable);
+            if (PyMethod_Check(m_callable))
+                py_func_obj = PyMethod_GET_FUNCTION(m_callable);
+            else
+                py_func_obj = m_callable;
+        }
+
+        if (py_func_obj)
+        {
+            PyCodeObject* code = (PyCodeObject*)PyFunction_GET_CODE(py_func_obj);
             if (code)
             {
                 size_t args = code->co_argcount;
                 bool va=false,kw=false;
                 if ((code->co_flags & 4) == 4)
                     va = true;
                 if ((code->co_flags & 8) == 8)
                     kw = true;
)
 
     PyObject* py_return = pfunc();
     return py_return;
 }
 
 SWIGEXPORT size_t
 LLDBSwigPython_CalculateNumChildren
 (
-    PyObject *implementor
+    PyObject *implementor,
+    uint32_t max
 )
 {
-    size_t ret_val = UINT32_MAX;
+    size_t ret_val = 0;
     bool int_match = false;
 
-    static char callee_name[] = "num_children";
+    PyCallable pfunc = PyCallable::FindWithMemberFunction(implementor, "num_children");
 
-    PyObject* py_return = LLDBSwigPython_CallOptionalMember(implementor,callee_name, NULL);
+    if (!pfunc)
+        return ret_val;
+
+    PyObject* py_return = NULL;
+    auto argc = pfunc.GetNumArguments();
+    if (argc.num_args == 1)
+        py_return = pfunc();
+    else if (argc.num_args == 2)
+        py_return = pfunc(max);
 
     if (!py_return)
         return ret_val;
 
     // PyInt_* are not available for Python 3 and above.
 #if PY_MAJOR_VERSION < 3
     if (PyInt_Check (py_return))
     {
#endif
     Py_XDECREF(py_return);
 
     if (PyErr_Occurred())
     {
         PyErr_Print();
         PyErr_Clear();
     }
 
+    if (argc.num_args == 1 && ret_val > max)
+        ret_val = max;
+
     return ret_val;
 }
 
 SWIGEXPORT PyObject*
 LLDBSwigPython_GetChildAtIndex
 (
     PyObject *implementor,
     uint32_t idx

scripts/interface/SBValue.i

public:
     /// @return
     ///     A new SBValue object that represents the child member value.
     //------------------------------------------------------------------
     ") GetChildAtIndex;
     lldb::SBValue
     GetChildAtIndex (uint32_t idx, 
                      lldb::DynamicValueType use_dynamic,
                      bool can_create_synthetic);
-    
     lldb::SBValue
     CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type);
     
     lldb::SBValue
     SBValue::Cast (lldb::SBType type);
 
     lldb::SBValue
     CreateValueFromExpression (const char *name, const char* expression);
CreateValueFromData (const char* name,
     MightHaveChildren ();
              
     bool
     IsRuntimeSupportValue ();
 
     uint32_t
     GetNumChildren ();
 
+    %feature("doctstring", "
+    //------------------------------------------------------------------
+    /// Returns the number for children. 
+    ///
+    /// @param[in] max
+    ///     If max is less the lldb.UINT32_MAX, then the returned value is
+    ///     capped to max.
+    ///
+    /// @return
+    ///     An integer value capped to the argument max.
+    //------------------------------------------------------------------
+    ") GetNumChildren;
+    uint32_t
+    GetNumChildren (uint32_t max);
+
     void *
     GetOpaqueType();
 
     lldb::SBValue
     Dereference ();
 
     lldb::SBValue
     AddressOf();

source/API/SBValue.cpp

if (log)
         log->Printf ("SBValue(%p)::IsRuntimeSupportValue() => %i",
                      static_cast<void*>(value_sp.get()), is_support);
     return is_support;
 }
 
 uint32_t
 SBValue::GetNumChildren ()
 {
+    return GetNumChildren (UINT32_MAX);
+}
+
+uint32_t
+SBValue::GetNumChildren (uint32_t max)
+{
     uint32_t num_children = 0;
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
-        num_children = value_sp->GetNumChildren();
+        num_children = value_sp->GetNumChildren(max);
 
     if (log)
-        log->Printf ("SBValue(%p)::GetNumChildren () => %u",
-                     static_cast<void*>(value_sp.get()), num_children);
+        log->Printf ("SBValue(%p)::GetNumChildren (%u) => %u",
+                     static_cast<void*>(value_sp.get()), max, num_children);
 
     return num_children;
 }
 
-
 SBValue
 SBValue::Dereference ()
 {
     SBValue sb_value;
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
     {

source/API/SystemInitializerFull.cpp

 
 extern "C" bool
 LLDBSWIGPythonCallThreadPlan (void *implementor,
                               const char *method_name,
                               Event *event_sp,
                               bool &got_error);
 
 extern "C" size_t
-LLDBSwigPython_CalculateNumChildren (void *implementor);
+LLDBSwigPython_CalculateNumChildren (void *implementor, uint32_t max);
 
 extern "C" void *
 LLDBSwigPython_GetChildAtIndex (void *implementor, uint32_t idx);
 
 extern "C" int
 LLDBSwigPython_GetIndexOfChildWithName (void *implementor, const char* child_name);
 
 extern "C" void *

source/Core/ValueObject.cpp

if (num_child_indexes > 0)
 
         }
     }
     return child_sp;
 }
 
 
 size_t
-ValueObject::GetNumChildren ()
+ValueObject::GetNumChildren (uint32_t max)
 {
     UpdateValueIfNeeded();
+
+    if (max < UINT32_MAX)
+    {
+        if (m_children_count_valid)
+        {
+            size_t children_count = m_children.GetChildrenCount();
+            return children_count <= max ? children_count : max;
+        }
+        else
+            return CalculateNumChildren(max);
+    }
+
     if (!m_children_count_valid)
     {
         SetNumChildren (CalculateNumChildren());
     }
     return m_children.GetChildrenCount();
 }
 
 bool

source/Core/ValueObjectCast.cpp

 
 CompilerType
 ValueObjectCast::GetCompilerTypeImpl ()
 {
     return m_cast_type;
 }
 
 size_t
-ValueObjectCast::CalculateNumChildren()
+ValueObjectCast::CalculateNumChildren(uint32_t max)
 {
-    return GetCompilerType().GetNumChildren (true);
+    auto children_count = GetCompilerType().GetNumChildren (true);
+    return children_count <= max ? children_count : max;
 }
 
 uint64_t
 ValueObjectCast::GetByteSize()
 {
     ExecutionContext exe_ctx (GetExecutionContextRef());
     return m_value.GetValueByteSize(nullptr, &exe_ctx);
 }

source/Core/ValueObjectChild.cpp

 
 lldb::ValueType
 ValueObjectChild::GetValueType() const
 {
     return m_parent->GetValueType();
 }
 
 size_t
-ValueObjectChild::CalculateNumChildren()
+ValueObjectChild::CalculateNumChildren(uint32_t max)
 {
-    return GetCompilerType().GetNumChildren (true);
+    auto children_count = GetCompilerType().GetNumChildren (true);
+    return children_count <= max ? children_count : max;
 }
 
 static void
 AdjustForBitfieldness(ConstString& name,
                       uint8_t bitfield_bit_size)
 {
     if (name && bitfield_bit_size)
     {

source/Core/ValueObjectConstResult.cpp

 
 void
 ValueObjectConstResult::SetByteSize (size_t size)
 {
     m_byte_size = size;
 }
 
 size_t
-ValueObjectConstResult::CalculateNumChildren()
+ValueObjectConstResult::CalculateNumChildren(uint32_t max)
 {
-    return GetCompilerType().GetNumChildren (true);
+    auto children_count = GetCompilerType().GetNumChildren (true);
+    return children_count <= max ? children_count : max;
 }
 
 ConstString
 ValueObjectConstResult::GetTypeName()
 {
     if (m_type_name.IsEmpty())
         m_type_name = GetCompilerType().GetConstTypeName ();
     return m_type_name;

source/Core/ValueObjectDynamicValue.cpp

if (success)
             return GetCompilerType().GetDisplayTypeName();
         if (m_dynamic_type_info.HasName())
             return m_dynamic_type_info.GetName();
     }
     return m_parent->GetDisplayTypeName();
 }
 
 size_t
-ValueObjectDynamicValue::CalculateNumChildren()
+ValueObjectDynamicValue::CalculateNumChildren(uint32_t max)
 {
     const bool success = UpdateValueIfNeeded(false);
     if (success && m_dynamic_type_info.HasType())
-        return GetCompilerType().GetNumChildren (true);
+    {
+        auto children_count = GetCompilerType().GetNumChildren (true);
+        return children_count <= max ? children_count : max;
+    }
     else
-        return m_parent->GetNumChildren();
+        return m_parent->GetNumChildren(max);
 }
 
 uint64_t
 ValueObjectDynamicValue::GetByteSize()
 {
     const bool success = UpdateValueIfNeeded(false);
     if (success && m_dynamic_type_info.HasType())
     {

source/Core/ValueObjectMemory.cpp

 ValueObjectMemory::GetDisplayTypeName()
 {
     if (m_type_sp)
         return m_type_sp->GetForwardCompilerType ().GetDisplayTypeName();
     return m_compiler_type.GetDisplayTypeName();
 }
 
 size_t
-ValueObjectMemory::CalculateNumChildren()
+ValueObjectMemory::CalculateNumChildren(uint32_t max)
 {
     if (m_type_sp)
-        return m_type_sp->GetNumChildren(true);
+    {
+        auto child_count = m_type_sp->GetNumChildren(true);
+        return child_count <= max ? child_count : max;
+    }
+
     const bool omit_empty_base_classes = true;
-    return m_compiler_type.GetNumChildren (omit_empty_base_classes);
+    auto child_count = m_compiler_type.GetNumChildren (omit_empty_base_classes);
+    return child_count <= max ? child_count : max;
 }
 
 uint64_t
 ValueObjectMemory::GetByteSize()
 {
     if (m_type_sp)
         return m_type_sp->GetByteSize();
     return m_compiler_type.GetByteSize (nullptr);

source/Core/ValueObjectRegister.cpp

 
 ConstString
 ValueObjectRegisterContext::GetQualifiedTypeName()
 {
     return ConstString();
 }
 
 size_t
-ValueObjectRegisterContext::CalculateNumChildren()
+ValueObjectRegisterContext::CalculateNumChildren(uint32_t max)
 {
-    return m_reg_ctx_sp->GetRegisterSetCount();
+    auto reg_set_count = m_reg_ctx_sp->GetRegisterSetCount();
+    return reg_set_count <= max ? reg_set_count : max;
 }
 
 uint64_t
 ValueObjectRegisterContext::GetByteSize()
 {
     return 0;
 }
 

 
 ConstString
 ValueObjectRegisterSet::GetQualifiedTypeName()
 {
     return ConstString();
 }
 
 size_t
-ValueObjectRegisterSet::CalculateNumChildren()
+ValueObjectRegisterSet::CalculateNumChildren(uint32_t max)
 {
     const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
     if (reg_set)
-        return reg_set->num_registers;
+    {
+        auto reg_count = reg_set->num_registers;
+        return reg_count <= max ? reg_count : max;
+    }
     return 0;
 }
 
 uint64_t
 ValueObjectRegisterSet::GetByteSize()
 {
     return 0;
 }

 ValueObjectRegister::GetTypeName()
 {
     if (m_type_name.IsEmpty())
         m_type_name = GetCompilerType().GetConstTypeName ();
     return m_type_name;
 }
 
 size_t
-ValueObjectRegister::CalculateNumChildren()
+ValueObjectRegister::CalculateNumChildren(uint32_t max)
 {
-    return GetCompilerType().GetNumChildren(true);
+    auto children_count = GetCompilerType().GetNumChildren (true);
+    return children_count <= max ? children_count : max;
 }
 
 uint64_t
 ValueObjectRegister::GetByteSize()
 {
     return m_reg_info.byte_size;
 }
 

source/Core/ValueObjectSyntheticFilter.cpp

 class DummySyntheticFrontEnd : public SyntheticChildrenFrontEnd
 {
 public:
     DummySyntheticFrontEnd(ValueObject &backend) :
     SyntheticChildrenFrontEnd(backend)
     {}
 
     size_t
-    CalculateNumChildren()
+    CalculateNumChildren ()
     {
         return m_backend.GetNumChildren();
     }
     
     lldb::ValueObjectSP
     GetChildAtIndex (size_t idx)
     {
         return m_backend.GetChildAtIndex(idx, true);
     }
-    
     size_t
     GetIndexOfChildWithName (const ConstString &name)
     {
         return m_backend.GetIndexOfChildWithName(name);
     }
     
     bool
     MightHaveChildren ()

 
 ConstString
 ValueObjectSynthetic::GetDisplayTypeName()
 {
     return m_parent->GetDisplayTypeName();
 }
 
 size_t
-ValueObjectSynthetic::CalculateNumChildren()
+ValueObjectSynthetic::CalculateNumChildren(uint32_t max)
 {
     UpdateValueIfNeeded();
     if (m_synthetic_children_count < UINT32_MAX)
-        return m_synthetic_children_count;
-    return (m_synthetic_children_count = m_synth_filter_ap->CalculateNumChildren());
+        return m_synthetic_children_count <= max ? m_synthetic_children_count : max;
+
+    if (max < UINT32_MAX)
+        return m_synth_filter_ap->CalculateNumChildren(max);
+    else
+        return (m_synthetic_children_count = m_synth_filter_ap->CalculateNumChildren(max));
 }
 
 lldb::ValueObjectSP
 ValueObjectSynthetic::GetDynamicValue (lldb::DynamicValueType valueType)
 {
     if (!m_parent)
         return lldb::ValueObjectSP();
     if (IsDynamic() && GetDynamicValueType() == valueType)

source/Core/ValueObjectVariable.cpp

 {
     Type * var_type = m_variable_sp->GetType();
     if (var_type)
         return var_type->GetQualifiedName();
     return ConstString();
 }
 
 size_t
-ValueObjectVariable::CalculateNumChildren()
+ValueObjectVariable::CalculateNumChildren(uint32_t max)
 {    
     CompilerType type(GetCompilerType());
     
     if (!type.IsValid())
         return 0;
     
     const bool omit_empty_base_classes = true;
-    return type.GetNumChildren(omit_empty_base_classes);
+    auto child_count = type.GetNumChildren(omit_empty_base_classes);
+    return child_count <= max ? child_count : max;
 }
 
 uint64_t
 ValueObjectVariable::GetByteSize()
 {
     ExecutionContext exe_ctx(GetExecutionContextRef());
     
     CompilerType type(GetCompilerType());

source/DataFormatters/TypeSynthetic.cpp

ScriptedSyntheticChildren::FrontEnd::IsValid ()
     return (m_wrapper_sp && m_wrapper_sp->IsValid() && m_interpreter);
 }
 
 size_t
 ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren ()
 {
     if (!m_wrapper_sp || m_interpreter == NULL)
         return 0;
-    return m_interpreter->CalculateNumChildren(m_wrapper_sp);
+    return m_interpreter->CalculateNumChildren(m_wrapper_sp, UINT32_MAX);
+}
+
+size_t
+ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren (uint32_t max)
+{
+    if (!m_wrapper_sp || m_interpreter == NULL)
+        return 0;
+    return m_interpreter->CalculateNumChildren(m_wrapper_sp, max);
 }
 
 bool
 ScriptedSyntheticChildren::FrontEnd::Update ()
 {
     if (!m_wrapper_sp || m_interpreter == NULL)
         return false;
     

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

typedef void* (*SWIGPythonCreateScriptedThreadPlan) (const char *python_class_name,
                                                         const lldb::ThreadPlanSP& thread_plan_sp);
 
     typedef bool (*SWIGPythonCallThreadPlan) (void *implementor, const char *method_name, Event *event_sp, bool &got_error);
 
     typedef void* (*SWIGPythonCreateOSPlugin) (const char *python_class_name,
                                                const char *session_dictionary_name,
                                                const lldb::ProcessSP& process_sp);
     
-    typedef size_t          (*SWIGPythonCalculateNumChildren)                   (void *implementor);
+    typedef size_t          (*SWIGPythonCalculateNumChildren)                   (void *implementor, uint32_t max);
     typedef void*           (*SWIGPythonGetChildAtIndex)                        (void *implementor, uint32_t idx);
     typedef int             (*SWIGPythonGetIndexOfChildWithName)                (void *implementor, const char* child_name);
     typedef void*           (*SWIGPythonCastPyObjectToSBValue)                  (void* data);
     typedef lldb::ValueObjectSP  (*SWIGPythonGetValueObjectSPFromSBValue)       (void* data);
     typedef bool            (*SWIGPythonUpdateSynthProviderInstance)            (void* data);
     typedef bool            (*SWIGPythonMightHaveChildrenSynthProviderInstance) (void* data);
     typedef void*           (*SWIGPythonGetValueSynthProviderInstance)          (void *implementor);
     
#endif
     StructuredData::DictionarySP OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid,
                                                        lldb::addr_t context) override;
 
     StructuredData::ObjectSP LoadPluginModule(const FileSpec &file_spec, lldb_private::Error &error) override;
 
     StructuredData::DictionarySP GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name,
                                                     lldb_private::Error &error) override;
 
-    size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor) override;
+    size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor, uint32_t max) override;
 
     lldb::ValueObjectSP GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) override;
 
     int GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name) override;
 
     bool UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor) override;
 
     bool MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor) override;

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

if (python_function_name && python_function_name[0])
         }
     }
     // We currently always true so we stop in case anything goes wrong when
     // trying to call the script function
     return true;
 }
 
 size_t
-ScriptInterpreterPython::CalculateNumChildren(const StructuredData::ObjectSP &implementor_sp)
+ScriptInterpreterPython::CalculateNumChildren(const StructuredData::ObjectSP &implementor_sp, uint32_t max)
 {
     if (!implementor_sp)
         return 0;
     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
     if (!generic)
         return 0;
     void *implementor = generic->GetValue();
     if (!implementor)
         return 0;
     
     if (!g_swig_calc_children)
         return 0;
 
     size_t ret_val = 0;
     
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_calc_children (implementor);
+        ret_val = g_swig_calc_children (implementor, max);
     }
     
     return ret_val;
 }
 
 lldb::ValueObjectSP
 ScriptInterpreterPython::GetChildAtIndex(const StructuredData::ObjectSP &implementor_sp, uint32_t idx)
 {

test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

def test_with_run_command(self):
 
         self.assertFalse(x_val() == 3, "x == 3 before synthetics")
         self.assertFalse(y_val() == 4, "y == 4 before synthetics")
         self.assertFalse(z_val() == 7, "z == 7 before synthetics")
 
         # now set up the synth
         self.runCmd("script from myIntSynthProvider import *")
         self.runCmd("type synth add -l myIntSynthProvider myInt")
+        self.runCmd("type synth add -l myArraySynthProvider myArray")
         
         if self.TraceOn():
             print "x_val = %s; y_val = %s; z_val = %s" % (x_val(),y_val(),z_val())
         
         self.assertTrue(x_val() == 3, "x != 3 after synthetics")
         self.assertTrue(y_val() == 4, "y != 4 after synthetics")
         self.assertTrue(z_val() == 7, "z != 7 after synthetics")
         
         self.expect("frame variable x", substrs=['3'])
         self.expect("frame variable x", substrs=['theValue = 3'], matching=False)
         
         # check that an aptly defined synthetic provider does not affect one-lining
         self.expect("expression struct S { myInt theInt{12}; }; S()", substrs = ['(theInt = 12)'])
         
         # check that we can use a synthetic value in a summary
         self.runCmd("type summary add hasAnInt -s ${var.theInt}")
         hi = self.frame().FindVariable("hi")
         self.assertEqual(hi.GetSummary(), "42")
 
+        ma = self.frame().FindVariable("ma")
+        self.assertTrue(ma.IsValid())
+        self.assertEqual(ma.GetNumChildren(15), 15)
+        self.assertEqual(ma.GetNumChildren(16), 16)
+        self.assertEqual(ma.GetNumChildren(17), 16)
+
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/functionalities/data-formatter/data-formatter-synthval/main.cpp

 class myInt {
     private: int theValue;
     public: myInt() : theValue(0) {}
     public: myInt(int _x) : theValue(_x) {}
     int val() { return theValue; }
 };
 
+class myArray {
+public:
+    int array[16];
+};
+
 class hasAnInt {
     public:
         myInt theInt;
         hasAnInt() : theInt(42) {}  
 };
 
 myInt operator + (myInt x, myInt y) { return myInt(x.val() + y.val()); }
 
 int main() {
     myInt x{3};
     myInt y{4};
     myInt z {x+y};
     hasAnInt hi;
+    myArray ma;
+
     return z.val(); // break here
 }

test/functionalities/data-formatter/data-formatter-synthval/myIntSynthProvider.py

def get_child_index(self, name):
       return None
   def update(self):
     return False
   def has_children(self):
       return False
   def get_value(self):
       return self.val
 
+
+class myArraySynthProvider(object):
+    def __init__(self, valobj, dict):
+        self.valobj = valobj
+        self.array = self.valobj.GetChildMemberWithName("array")
+
+    def num_children(self, max_count):
+        if 16 < max_count:
+            return 16
+        return max_count
+
+    def get_child_at_index(self, index):
+        return None # Keep it simple when this is not tested here.
+
+    def get_child_index(self, name):
+        return None # Keep it simple when this is not tested here.
+
+    def has_children(self):
+        return True