Add a pretty printer extension to directly return the number of children

This avoids us needing to enumerate the children one by one (if the
pretty printer supports the extension).

To keep the pretty printer interface consistent, I've define the
extensions in terms of the number of children returned/yielded by the
`children()` function rather than the number of entries in a map, even
though this means that most map pretty printers will need to multiple
the number of elemnts by two, only for GALA to divide it again.

I'm also passing down the `max_count` value we get from lldb, in it's
useful in some pretty printers for limiting the amount of work.

With llvm/llvm-project#93946, lldb will pass down reasonable values for
max_count, so we might be able to remove the limiting hack on the
fallback path, but I'm leaving that for a separate patch/discussion.

Author: labath

gdb/printing.py

@@ -194,12 +194,16 @@ def __init__(
             self._children_iterator = None
             self._iter_count = 0
             self._captured_errors = []
+            self._child_coeff = 1
             self.find_pretty_printer()
 
         @_set_current_target
         def find_pretty_printer(self):
             try:
                 self._pp = make_printer_func(gdb.Value(self._sbvalue))
+                if self._get_display_hint() == 'map':
+                    # For maps two gdb children count as one lldb child
+                    self._child_coeff = 2
             except:
                 self._captured_errors.append(
                     'Error calling into GDB printer "%s".\n%s'
@@ -279,6 +283,10 @@ def _get_display_hint(self) -> str:
 
         @_set_current_target
         def num_children(self, max_count: int) -> int:
+            # See if the prettyprinter supports our num_children extension.
+            if hasattr(self._pp, 'num_children'):
+                return self._pp.num_children(max_count * self._child_coeff) // self._child_coeff
+
             # gdb prettyprinters don't directly compute the number of children.
             # They expose a `children` iterator function instead, and it will
             # be called at most as many times as specified by `set print
@@ -301,12 +309,8 @@ def num_children(self, max_count: int) -> int:
             if print_elements is not None:
               max_count = min(max_count, print_elements + 1)
 
-            if self._get_display_hint() == 'map':
-                self._get_children(2 * max_count)
-                return min(len(self._children) // 2, max_count)
-            else:
-                self._get_children(max_count)
-                return min(len(self._children), max_count)
+            self._get_children(max_count * self._child_coeff)
+            return len(self._children) // self._child_coeff
 
         @_set_current_target
         def get_child_index(self, name: str) -> int:
@@ -319,13 +323,13 @@ def get_child_index(self, name: str) -> int:
 
         @_set_current_target
         def get_child_at_index(self, index: int) -> Optional[lldb.SBValue]:
+            self._get_children((index + 1) * self._child_coeff)
             # lldb-vscode currently relies on the fact that passing an invalid
             # index to SBValue.GetChildAtIndex "works" (it returns a non-valid
             # SBValue). Asserting here causes scary error messages in the log,
             # so just return None for compatibility.
-            if self._get_display_hint() == 'map':
-                self._get_children(2 * (index + 1))
-                if index < (len(self._children) / 2):
+            if index < (len(self._children) // self._child_coeff):
+                if self._get_display_hint() == 'map':
                     key = self._children[index * 2][1]
                     val = self._children[index * 2 + 1][1]
                     if isinstance(key, gdb.Value):
@@ -337,9 +341,7 @@ def get_child_at_index(self, index: int) -> Optional[lldb.SBValue]:
                     else:
                         key_str = str(key)
                     return _named_sbvalue(self._sbvalue, '[%s]' % key_str, val)
-            else:
-                self._get_children(index + 1)
-                if index < len(self._children):
+                else:
                     c = self._children[index]
                     return _named_sbvalue(self._sbvalue, c[0], c[1])
             return None

test/lit/num_children.test

@@ -0,0 +1,20 @@
+Test our num_children pretty printer extension.
+
+RUN: %clangxx -g -o %t num_children/test_program.cc
+RUN: %lldb %t -b \
+RUN:       -o 'settings set target.max-children-count 142' \
+RUN:       -o 'script import num_children' \
+RUN:       -o 'script print("num_children = ", lldb.target.FindFirstGlobalVariable("s").GetNumChildren(47))' \
+RUN:       -o 'script print("MAX_MAX_COUNT = ", num_children.MyStructPrinter.MAX_MAX_COUNT)' \
+RUN:       -o 'target variable s' \
+RUN:       -o 'script print("MAX_MAX_COUNT = ", num_children.MyStructPrinter.MAX_MAX_COUNT)' \
+RUN:       | FileCheck %s
+
+CHECK: num_children = 2
+CHECK: MAX_MAX_COUNT = 94
+CHECK: (MyStruct) s = A pretty MyStruct {
+CHECK-NEXT:  [key0] = "val0"
+CHECK-NEXT:  [key1] = "val1"
+CHECK-NEXT: }
+# 2 * (142 + 1)
+CHECK: MAX_MAX_COUNT = 286

test/lit/num_children/__init__.py

@@ -0,0 +1,29 @@
+import gdb
+import gdb.printing
+
+class MyStructPrinter:
+  MAX_MAX_COUNT = 0
+
+  def __init__(self, val):
+    self._val = val
+
+  def display_hint(self):
+    return "map"
+
+  def to_string(self):
+    return "A pretty MyStruct"
+
+  def num_children(self, max_count):
+    MyStructPrinter.MAX_MAX_COUNT = max(MyStructPrinter.MAX_MAX_COUNT, max_count)
+    return 4
+
+  def children(self):
+    yield "key[0]", "key0"
+    yield "val[0]", "val0"
+    yield "key[1]", "key1"
+    yield "val[1]", "val1"
+
+printer = gdb.printing.RegexpCollectionPrettyPrinter("test_regexp_printer")
+printer.add_printer("MyStruct", "MyStruct", MyStructPrinter)
+
+gdb.printing.register_pretty_printer(gdb.current_objfile(), printer)

test/lit/num_children/test_program.cc

@@ -0,0 +1,5 @@
+struct MyStruct {};
+
+MyStruct s;
+
+int main() { return 0; }