Re: [RFC 1/2] gdb: enable [] to find children using pretty-printers

[Simon Marchi <simon.marchi@polymtl.ca>]

On 2021-04-22 10:10 a.m., Andrew Burgess wrote:
> This commit allows GDB to make use of an available pretty-printer to
> provide [] indexing into a type.
> 
> Consider the following example before any pretty-printer is loaded:
> 
>   (gdb) p obj_int
>   $1 = {
>     m_name = 0x4052a0 "first int array",
>     m_nitems = 4,
>     m_items = 0x4052c0
>   }
>   (gdb) p obj_int[3]
>   Structure has no component named operator[].
> 
> Now, after loading a pretty-printer:
> 
>   (gdb) p obj_int
>   $2 = int array "first int array" with 4 elements = {3, 6, 4, 2}
>   (gdb) p obj_int[3]
>   $3 = 2

When reading this, I thought: isn't what pretty printers already do?
But apparently not.

It sounds at first like there's an overlap with xmethods, but maybe not
completely.  From what I understand, you would only write an xmethod to
replicate a method that exists in the program, but which may not be
available to call.  If writing a pretty printer for an array-like
structure in C, then there's no concept of method at all, so you
couldn't write an xmethod I suppose.  So this is where I can see your
feature becoming handy.

> diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
> index 7c0fdaa9e70..effbfcbfe28 100644
> --- a/gdb/python/py-prettyprint.c
> +++ b/gdb/python/py-prettyprint.c
> @@ -684,3 +684,173 @@ gdbpy_default_visualizer (PyObject *self, PyObject *args)
>  
>    return find_pretty_printer (val_obj).release ();
>  }
> +
> +/* See ext_lang_pretty_printer_find_child in extension.h for details.  */
> +
> +struct value *
> +gdbpy_val_pretty_printer_find_child (const extension_language_defn *extlang,
> +				     struct value *object,
> +				     struct value *idx,
> +				     const language_defn *language)
> +{
> +  /* A simple wrapper to make returning easier.  If we got an error then
> +     print the Python stack, and return nullptr.  Otherwise, return the
> +     value passed in.  */
> +  auto print_errors_before_return = [] (struct value *ret) -> struct value *
> +  {
> +    if (PyErr_Occurred ())
> +      {
> +	if (!PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
> +	  {
> +	    ret = nullptr;
> +	    gdbpy_print_stack ();
> +	  }
> +      }
> +    return ret;
> +  };
> +
> +  struct gdbarch *gdbarch = value_type (object)->arch ();
> +
> +  gdbpy_enter enter_py (gdbarch, language);
> +
> +  /* Prepare the value to be passed to the pretty printer.  */
> +  gdbpy_ref<> val_obj (value_to_value_object_no_release (object));
> +  if (val_obj == nullptr)
> +    return print_errors_before_return (nullptr);
> +
> +  /* Find the pretty-printer constructor.  */
> +  gdbpy_ref<> printer (find_pretty_printer (val_obj.get ()));
> +  if (printer == nullptr || printer == Py_None)
> +    return print_errors_before_return (nullptr);
> +
> +  /* If the pretty printer has no 'children' method then we're not going to
> +     be able to lookup any children.  */
> +  if (!PyObject_HasAttr (printer.get (), gdbpy_children_cst))
> +    return print_errors_before_return (nullptr);
> +
> +  /* If we get here then the pretty printer has no 'child' method, but does
> +     have the 'children' method.  We can manually walk the children and
> +     find one that matches IDX.  First, find out how the children are
> +     represented by the children method.  */

Here, you talk about the child method, but I couldn't find any doc /
code about that.

While reading the commit message, I had that thought, maybe you had the
same.  If you do:

  (gdb) print myobject[50000]

That kind sucks that we have to call the "children" method and consume
/ create 49999 values that we are not going to use.  It would be much
better if we could ask the pretty printer, give me the item at index
50000.  Reading the documented API [1], that doesn't seem possible.

[1] https://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing-API.html#Pretty-Printing-API

Simon