public inbox for gdb-patches@sourceware.org
 help / color / mirror / Atom feed
From: Gareth Rees <grees@undo.io>
To: gdb-patches@sourceware.org
Subject: Re: [PING] [PATCH v5] [PR mi/29554] New PRINT-VALUES option '--scalar-values'.
Date: Thu, 1 Dec 2022 13:41:17 +0000	[thread overview]
Message-ID: <CAA8DSpFwdYGSDSECp741VwC5Prjw=3EZ7COLchRxbYeZjFxUbw@mail.gmail.com> (raw)
In-Reply-To: <CAA8DSpHnpNnCxFg8aFV+_npEyjbY4upBcKvgCO6uYZGyHMc9Sg@mail.gmail.com>

Is there anything I can do to help progress this?


On Thu, 3 Nov 2022 at 16:20, Gareth Rees <grees@undo.io> wrote:
>
> After four rounds of review, this must be getting close to being
> mergeable! But do let me know if there's anything else that I need to
> improve here.
>
>
> On Thu, 20 Oct 2022 at 18:47, Gareth Rees <grees@undo.io> wrote:
> >
> > SUMMARY
> >
> > The '--simple-values' argument to '-stack-list-arguments' and similar
> > GDB/MI commands does not take reference types into account, so that
> > references to arbitrarily large structures are considered "simple" and
> > printed. This means that the '--simple-values' argument cannot be used
> > by IDEs when tracing the stack due to the time taken to print large
> > structures passed by reference.
> >
> > DETAILS
> >
> > Various GDB/MI commands ('-stack-list-arguments', '-stack-list-locals',
> > '-stack-list-variables' and so on) take a PRINT-VALUES argument which
> > may be '--no-values' (0), '--all-values' (1) or '--simple-values' (2).
> > In the '--simple-values' case, the command is supposed to print the
> > name, type, and value of variables with simple types, and print only the
> > name and type of variables with compound types.
> >
> > The '--simple-values' argument ought to be suitable for IDEs that need
> > to update their user interface with the program's call stack every time
> > the program stops. However, it does not take C++ reference types into
> > account, and this makes the argument unsuitable for this purpose.
> >
> > For example, consider the following C++ program:
> >
> >     struct s {
> >         int v[10];
> >     };
> >
> >     int
> >     sum(const struct s &s)
> >     {
> >         int total = 0;
> >         for (int i = 0; i < 10; ++i) total += s.v[i];
> >         return total;
> >     }
> >
> >     int
> >     main(void)
> >     {
> >         struct s s = { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } };
> >         return sum(s);
> >     }
> >
> > If we start GDB in MI mode and continue to 'sum', the behaviour of
> > '-stack-list-arguments' is as follows:
> >
> >     (gdb)
> >     -stack-list-arguments --simple-values
> >     ^done,stack-args=[frame={level="0",args=[{name="s",type="const s &",value="@0x7fffffffe310: {v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}"}]},frame={level="1",args=[]}]
> >
> > Note that the value of the argument 's' was printed, even though 's' is
> > a reference to a structure, which is not a simple value.
> >
> > See https://github.com/microsoft/MIEngine/pull/673 for a case where this
> > behaviour caused Microsoft to avoid the use of '--simple-values' in
> > their MIEngine debug adapter, because it caused Visual Studio Code to
> > take too long to refresh the call stack in the user interface.
> >
> > SOLUTIONS
> >
> > There are two ways we could fix this problem, depending on whether we
> > consider the current behaviour to be a bug that can be fixed.
> >
> > 1. If the current behaviour is a bug that can be fixed, then we can
> >    update the behaviour of '--simple-values' so that it takes
> >    reference types into account: that is, a value is simple if it is
> >    neither an array, struct, or union, nor a reference to an array,
> >    struct or union.
> >
> >    In this case we must add a feature to the '-list-features' command so
> >    that IDEs can detect that it is safe to use the '--simple-values'
> >    argument when refreshing the call stack.
> >
> > 2. If the current behaviour is not a bug, or cannot be changed due to
> >    backwards compatibility concerns, then we can add a new option for
> >    the PRINT-VALUES argument, for example, '--scalar-values' (3), that
> >    would be suitable for use by IDEs.
> >
> >    In this case we must add a feature to the '-list-features' command so
> >    that IDEs can detect that the '--scalar-values' argument is
> >    available for use when refreshing the call stack.
> >
> > PATCH
> >
> > This patch implements solution (2), adding a '--scalar-values' option
> > for the PRINT-VALUES argument to '-stack-list-arguments' and similar
> > commands. This option prints the value only for scalars and so matches
> > the behaviour of the 'scalars' argument to the 'set print
> > frame-arguments' command. References to structures are not scalars,
> > and so the option is suitable for use by IDEs.
> >
> > Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=29554
> > ---
> >  gdb/NEWS                                      |  9 +++
> >  gdb/doc/gdb.texinfo                           | 59 ++++++++++-------
> >  gdb/extension.h                               |  3 +
> >  gdb/mi/mi-cmd-stack.c                         | 16 ++---
> >  gdb/mi/mi-cmd-var.c                           | 45 ++++++++++---
> >  gdb/mi/mi-cmds.h                              | 17 ++++-
> >  gdb/mi/mi-main.c                              | 35 ++++-------
> >  gdb/mi/mi-parse.c                             |  8 ++-
> >  gdb/python/py-framefilter.c                   | 40 ++++++------
> >  gdb/testsuite/gdb.mi/mi-stack.exp             | 37 ++++++++++-
> >  gdb/testsuite/gdb.mi/print-values.cc          | 63 +++++++++++++++++++
> >  gdb/testsuite/gdb.mi/print-values.exp         | 53 ++++++++++++++++
> >  .../gdb.python/py-framefilter-mi.exp          | 28 +++++++++
> >  13 files changed, 323 insertions(+), 90 deletions(-)
> >  create mode 100644 gdb/testsuite/gdb.mi/print-values.cc
> >  create mode 100644 gdb/testsuite/gdb.mi/print-values.exp
> >
> > diff --git a/gdb/NEWS b/gdb/NEWS
> > index dee0ac2ecd8..9ad441691ea 100644
> > --- a/gdb/NEWS
> > +++ b/gdb/NEWS
> > @@ -114,6 +114,15 @@ maintenance info line-table
> >    entry corresponds to an address where a breakpoint should be placed
> >    to be at the first instruction past a function's prologue.
> >
> > +* MI changes
> > +
> > +  ** The '-stack-list-arguments', '-stack-list-locals',
> > +     '-stack-list-variables', and '-var-list-children' commands
> > +     support the '--scalar-values' option, which requests the command
> > +     to print values only for scalar types.  Support for this feature
> > +     can be verified by using the '-list-features' command, which
> > +     now includes "scalar-values".
> > +
> >  * New targets
> >
> >  GNU/Linux/LoongArch (gdbserver)        loongarch*-*-linux*
> > diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
> > index 238a49b027d..b2b53de1022 100644
> > --- a/gdb/doc/gdb.texinfo
> > +++ b/gdb/doc/gdb.texinfo
> > @@ -33326,12 +33326,14 @@ larger than the actual number of frames.  On the other hand,
> >  @var{high-frame} may be larger than the actual number of frames, in
> >  which case only existing frames will be returned.
> >
> > -If @var{print-values} is 0 or @code{--no-values}, print only the names of
> > -the variables; if it is 1 or @code{--all-values}, print also their
> > -values; and if it is 2 or @code{--simple-values}, print the name,
> > -type and value for simple data types, and the name and type for arrays,
> > -structures and unions.  If the option @code{--no-frame-filters} is
> > -supplied, then Python frame filters will not be executed.
> > +If @var{print-values} is 0 or @code{--no-values}, print only the names
> > +of the variables; if it is 1 or @code{--all-values}, print also their
> > +values; if it is 2 or @code{--simple-values}, print the name, type and
> > +value for simple data types, and the name and type for arrays,
> > +structures and unions; and if it is 3 or @code{--scalar-values}, print
> > +the name, type and value for scalar data types, and the name and type
> > +otherwise.  If the option @code{--no-frame-filters} is supplied, then
> > +Python frame filters will not be executed.
> >
> >  If the @code{--skip-unavailable} option is specified, arguments that
> >  are not available are not listed.  Partially available arguments
> > @@ -33549,13 +33551,15 @@ Show a single frame:
> >  Display the local variable names for the selected frame.  If
> >  @var{print-values} is 0 or @code{--no-values}, print only the names of
> >  the variables; if it is 1 or @code{--all-values}, print also their
> > -values; and if it is 2 or @code{--simple-values}, print the name,
> > -type and value for simple data types, and the name and type for arrays,
> > -structures and unions.  In this last case, a frontend can immediately
> > -display the value of simple data types and create variable objects for
> > -other data types when the user wishes to explore their values in
> > -more detail.  If the option @code{--no-frame-filters} is supplied, then
> > -Python frame filters will not be executed.
> > +values; if it is 2 or @code{--simple-values}, print the name, type and
> > +value for simple data types, and the name and type for arrays,
> > +structures and unions; and if it is 3 or @code{--scalar-values}, print
> > +the name, type and value for scalar data types, and the name and type
> > +otherwise.  In the last two cases, a frontend can immediately display
> > +the value of simple or scalar data types and create variable objects
> > +for other data types when the user wishes to explore their values in
> > +more detail.  If the option @code{--no-frame-filters} is supplied,
> > +then Python frame filters will not be executed.
> >
> >  If the @code{--skip-unavailable} option is specified, local variables
> >  that are not available are not listed.  Partially available local
> > @@ -33594,13 +33598,16 @@ This command is deprecated in favor of the
> >   -stack-list-variables [ --no-frame-filters ] [ --skip-unavailable ] @var{print-values}
> >  @end smallexample
> >
> > -Display the names of local variables and function arguments for the selected frame.  If
> > -@var{print-values} is 0 or @code{--no-values}, print only the names of
> > -the variables; if it is 1 or @code{--all-values}, print also their
> > -values; and if it is 2 or @code{--simple-values}, print the name,
> > -type and value for simple data types, and the name and type for arrays,
> > -structures and unions.  If the option @code{--no-frame-filters} is
> > -supplied, then Python frame filters will not be executed.
> > +Display the names of local variables and function arguments for the
> > +selected frame.  If @var{print-values} is 0 or @code{--no-values},
> > +print only the names of the variables; if it is 1 or
> > +@code{--all-values}, print also their values; if it is 2 or
> > +@code{--simple-values}, print the name, type and value for simple data
> > +types, and the name and type for arrays, structures and unions; and if
> > +it is 3 or @code{--scalar-values}, print the name, type and value for
> > +scalar data types, and the name and type otherwise.  If the option
> > +@code{--no-frame-filters} is supplied, then Python frame filters will
> > +not be executed.
> >
> >  If the @code{--skip-unavailable} option is specified, local variables
> >  and arguments that are not available are not listed.  Partially
> > @@ -34029,9 +34036,10 @@ create variable objects for them, if they do not already exist.  With
> >  a single argument or if @var{print-values} has a value of 0 or
> >  @code{--no-values}, print only the names of the variables; if
> >  @var{print-values} is 1 or @code{--all-values}, also print their
> > -values; and if it is 2 or @code{--simple-values} print the name and
> > -value for simple data types and just the name for arrays, structures
> > -and unions.
> > +values; if it is 2 or @code{--simple-values} print the name and value
> > +for simple data types and just the name for arrays, structures and
> > +unions; and if it is 3 or @code{--scalar-values}, print the name and
> > +value for scalar data types, and just the name otherwise.
> >
> >  @var{from} and @var{to}, if specified, indicate the range of children
> >  to report.  If @var{from} or @var{to} is less than zero, the range is
> > @@ -37295,6 +37303,11 @@ option (@pxref{GDB/MI Program Execution}).
> >  @item data-disassemble-a-option
> >  Indicates that the @code{-data-disassemble} command supports the @option{-a}
> >  option (@pxref{GDB/MI Data Manipulation}).
> > +@item scalar-values
> > +Indicates that the @code{-stack-list-arguments},
> > +@code{-stack-list-locals}, @code{-stack-list-variables}, and
> > +@code{-var-list-children} commands support the
> > +@option{--scalar-values} option (@pxref{GDB/MI Stack Manipulation}).
> >  @end ftable
> >
> >  @subheading The @code{-list-target-features} Command
> > diff --git a/gdb/extension.h b/gdb/extension.h
> > index 47839ea50be..16d12f00f41 100644
> > --- a/gdb/extension.h
> > +++ b/gdb/extension.h
> > @@ -121,6 +121,9 @@ enum ext_lang_frame_args
> >         arguments when invoked from the MI. */
> >      MI_PRINT_SIMPLE_VALUES = PRINT_SIMPLE_VALUES,
> >
> > +    /* Print only scalar values for arguments when invoked from the MI.  */
> > +    MI_PRINT_SCALAR_VALUES = PRINT_SCALAR_VALUES,
> > +
> >      /* Print only scalar values for arguments when invoked from the CLI. */
> >      CLI_SCALAR_VALUES,
> >
> > diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c
> > index 0fe204dbc66..43eea32e460 100644
> > --- a/gdb/mi/mi-cmd-stack.c
> > +++ b/gdb/mi/mi-cmd-stack.c
> > @@ -494,6 +494,7 @@ list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
> >    gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
> >                && arg->error == NULL)
> >               || values == PRINT_SIMPLE_VALUES
> > +             || values == PRINT_SCALAR_VALUES
> >               || (values == PRINT_ALL_VALUES
> >                   && (arg->val != NULL || arg->error != NULL)));
> >    gdb_assert (arg->entry_kind == print_entry_values_no
> > @@ -525,7 +526,8 @@ list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
> >    if (what == all && arg->sym->is_argument ())
> >      uiout->field_signed ("arg", 1);
> >
> > -  if (values == PRINT_SIMPLE_VALUES)
> > +  if (values == PRINT_SIMPLE_VALUES
> > +      || values == PRINT_SCALAR_VALUES)
> >      {
> >        check_typedef (arg->sym->type ());
> >        type_print (arg->sym->type (), "", &stb, -1);
> > @@ -571,7 +573,6 @@ list_args_or_locals (const frame_print_options &fp_opts,
> >    const struct block *block;
> >    struct symbol *sym;
> >    struct block_iterator iter;
> > -  struct type *type;
> >    const char *name_of_result;
> >    struct ui_out *uiout = current_uiout;
> >
> > @@ -647,21 +648,12 @@ list_args_or_locals (const frame_print_options &fp_opts,
> >               entryarg.sym = sym2;
> >               entryarg.entry_kind = print_entry_values_no;
> >
> > -             switch (values)
> > +             if (mi_print_type_p (sym->type (), values))
> >                 {
> > -               case PRINT_SIMPLE_VALUES:
> > -                 type = check_typedef (sym2->type ());
> > -                 if (type->code () != TYPE_CODE_ARRAY
> > -                     && type->code () != TYPE_CODE_STRUCT
> > -                     && type->code () != TYPE_CODE_UNION)
> > -                   {
> > -               case PRINT_ALL_VALUES:
> >                   if (sym->is_argument ())
> >                     read_frame_arg (fp_opts, sym2, fi, &arg, &entryarg);
> >                   else
> >                     read_frame_local (sym2, fi, &arg);
> > -                   }
> > -                 break;
> >                 }
> >
> >               if (arg.entry_kind != print_entry_values_only)
> > diff --git a/gdb/mi/mi-cmd-var.c b/gdb/mi/mi-cmd-var.c
> > index 3db09cf7815..1d4d3ec8534 100644
> > --- a/gdb/mi/mi-cmd-var.c
> > +++ b/gdb/mi/mi-cmd-var.c
> > @@ -32,6 +32,7 @@
> >  #include "mi-parse.h"
> >  #include "gdbsupport/gdb_optional.h"
> >  #include "inferior.h"
> > +#include "valprint.h"
> >
> >  static void varobj_update_one (struct varobj *var,
> >                                enum print_values print_values,
> > @@ -314,6 +315,40 @@ mi_cmd_var_info_num_children (const char *command, char **argv, int argc)
> >    uiout->field_signed ("numchild", varobj_get_num_children (var));
> >  }
> >
> > +/* See mi-cmds.h.  */
> > +
> > +bool
> > +mi_simple_type_p (struct type *type)
> > +{
> > +  type = check_typedef (type);
> > +  switch (type->code ())
> > +    {
> > +    case TYPE_CODE_ARRAY:
> > +    case TYPE_CODE_STRUCT:
> > +    case TYPE_CODE_UNION:
> > +      return false;
> > +    default:
> > +      return true;
> > +    }
> > +}
> > +
> > +bool
> > +mi_print_type_p (struct type *type, enum print_values print_values)
> > +{
> > +  switch (print_values)
> > +    {
> > +    default:
> > +    case PRINT_NO_VALUES:
> > +      return false;
> > +    case PRINT_ALL_VALUES:
> > +      return true;
> > +    case PRINT_SIMPLE_VALUES:
> > +      return mi_simple_type_p (type);
> > +    case PRINT_SCALAR_VALUES:
> > +      return val_print_scalar_type_p (type);
> > +    }
> > +}
> > +
> >  /* Return 1 if given the argument PRINT_VALUES we should display
> >     the varobj VAR.  */
> >
> > @@ -335,15 +370,7 @@ mi_print_value_p (struct varobj *var, enum print_values print_values)
> >    if (type == NULL)
> >      return 1;
> >    else
> > -    {
> > -      type = check_typedef (type);
> > -
> > -      /* For PRINT_SIMPLE_VALUES, only print the value if it has a type
> > -        and that type is not a compound type.  */
> > -      return (type->code () != TYPE_CODE_ARRAY
> > -             && type->code () != TYPE_CODE_STRUCT
> > -             && type->code () != TYPE_CODE_UNION);
> > -    }
> > +    return mi_print_type_p (type, print_values);
> >  }
> >
> >  void
> > diff --git a/gdb/mi/mi-cmds.h b/gdb/mi/mi-cmds.h
> > index 9ffb11bf997..3a5b6b72be9 100644
> > --- a/gdb/mi/mi-cmds.h
> > +++ b/gdb/mi/mi-cmds.h
> > @@ -29,7 +29,8 @@
> >  enum print_values {
> >     PRINT_NO_VALUES,
> >     PRINT_ALL_VALUES,
> > -   PRINT_SIMPLE_VALUES
> > +   PRINT_SIMPLE_VALUES,
> > +   PRINT_SCALAR_VALUES
> >  };
> >
> >  typedef void (mi_cmd_argv_ftype) (const char *command, char **argv, int argc);
> > @@ -226,4 +227,18 @@ using remove_mi_cmd_entries_ftype
> >    = gdb::function_view<bool (mi_command *)>;
> >  extern void remove_mi_cmd_entries (remove_mi_cmd_entries_ftype callback);
> >
> > +/* Return true if TYPE is suitable for printing with PRINT_SIMPLE_VALUES: that
> > +   is, if TYPE is not an array, structure or union.
> > +
> > +   Note that reference types are always considered simple by this function, even
> > +   if the referenced type is non-scalar.  This behaviour is retained for backwards
> > +   compatibility, and PRINT_SCALAR_VALUES may be used instead to avoid printing
> > +   references to non-scalar values.  */
> > +
> > +extern bool mi_simple_type_p (struct type *type);
> > +
> > +/* Return true if TYPE is suitable for printing with PRINT_VALUES.  */
> > +
> > +extern bool mi_print_type_p (struct type *type, enum print_values values);
> > +
> >  #endif /* MI_MI_CMDS_H */
> > diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
> > index b758f398e2a..9bb00390370 100644
> > --- a/gdb/mi/mi-main.c
> > +++ b/gdb/mi/mi-main.c
> > @@ -1663,6 +1663,7 @@ mi_cmd_list_features (const char *command, char **argv, int argc)
> >        uiout->field_string (NULL, "undefined-command-error-code");
> >        uiout->field_string (NULL, "exec-run-start-option");
> >        uiout->field_string (NULL, "data-disassemble-a-option");
> > +      uiout->field_string (NULL, "scalar-values");
> >
> >        if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
> >         uiout->field_string (NULL, "python");
> > @@ -2462,14 +2463,14 @@ static void
> >  print_variable_or_computed (const char *expression, enum print_values values)
> >  {
> >    struct value *val;
> > -  struct type *type;
> >    struct ui_out *uiout = current_uiout;
> >
> >    string_file stb;
> >
> >    expression_up expr = parse_expression (expression);
> >
> > -  if (values == PRINT_SIMPLE_VALUES)
> > +  if (values == PRINT_SIMPLE_VALUES
> > +      || values == PRINT_SCALAR_VALUES)
> >      val = evaluate_type (expr.get ());
> >    else
> >      val = evaluate_expression (expr.get ());
> > @@ -2482,31 +2483,19 @@ print_variable_or_computed (const char *expression, enum print_values values)
> >    switch (values)
> >      {
> >      case PRINT_SIMPLE_VALUES:
> > -      type = check_typedef (value_type (val));
> > +    case PRINT_SCALAR_VALUES:
> >        type_print (value_type (val), "", &stb, -1);
> >        uiout->field_stream ("type", stb);
> > -      if (type->code () != TYPE_CODE_ARRAY
> > -         && type->code () != TYPE_CODE_STRUCT
> > -         && type->code () != TYPE_CODE_UNION)
> > -       {
> > -         struct value_print_options opts;
> > -
> > -         get_no_prettyformat_print_options (&opts);
> > -         opts.deref_ref = 1;
> > -         common_val_print (val, &stb, 0, &opts, current_language);
> > -         uiout->field_stream ("value", stb);
> > -       }
> >        break;
> > -    case PRINT_ALL_VALUES:
> > -      {
> > -       struct value_print_options opts;
> > +    }
> >
> > -       get_no_prettyformat_print_options (&opts);
> > -       opts.deref_ref = 1;
> > -       common_val_print (val, &stb, 0, &opts, current_language);
> > -       uiout->field_stream ("value", stb);
> > -      }
> > -      break;
> > +  if (mi_print_type_p (value_type (val), values))
> > +    {
> > +      struct value_print_options opts;
> > +      get_no_prettyformat_print_options (&opts);
> > +      opts.deref_ref = 1;
> > +      common_val_print (val, &stb, 0, &opts, current_language);
> > +      uiout->field_stream ("value", stb);
> >      }
> >  }
> >
> > diff --git a/gdb/mi/mi-parse.c b/gdb/mi/mi-parse.c
> > index dfa7b462714..dd70e4648a1 100644
> > --- a/gdb/mi/mi-parse.c
> > +++ b/gdb/mi/mi-parse.c
> > @@ -29,6 +29,7 @@
> >  #include "language.h"
> >
> >  static const char mi_no_values[] = "--no-values";
> > +static const char mi_scalar_values[] = "--scalar-values";
> >  static const char mi_simple_values[] = "--simple-values";
> >  static const char mi_all_values[] = "--all-values";
> >
> > @@ -383,8 +384,11 @@ mi_parse_print_values (const char *name)
> >     else if (strcmp (name, "2") == 0
> >             || strcmp (name, mi_simple_values) == 0)
> >       return PRINT_SIMPLE_VALUES;
> > +   else if (strcmp (name, "3") == 0
> > +           || strcmp (name, mi_scalar_values) == 0)
> > +     return PRINT_SCALAR_VALUES;
> >     else
> >       error (_("Unknown value for PRINT_VALUES: must be: \
> > -0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
> > -           mi_no_values, mi_all_values, mi_simple_values);
> > +0 or \"%s\", 1 or \"%s\", 2 or \"%s\", 3 or \"%s\""),
> > +           mi_no_values, mi_all_values, mi_simple_values, mi_scalar_values);
> >  }
> > diff --git a/gdb/python/py-framefilter.c b/gdb/python/py-framefilter.c
> > index 366f3745b9d..e295036f46e 100644
> > --- a/gdb/python/py-framefilter.c
> > +++ b/gdb/python/py-framefilter.c
> > @@ -227,26 +227,27 @@ py_print_value (struct ui_out *out, struct value *val,
> >                 enum ext_lang_frame_args args_type,
> >                 const struct language_defn *language)
> >  {
> > -  int should_print = 0;
> > +  int should_print;
> >
> >    /* MI does not print certain values, differentiated by type,
> >       depending on what ARGS_TYPE indicates.  Test type against option.
> >       For CLI print all values.  */
> > -  if (args_type == MI_PRINT_SIMPLE_VALUES
> > -      || args_type == MI_PRINT_ALL_VALUES)
> > +  switch (args_type)
> >      {
> > -      struct type *type = check_typedef (value_type (val));
> > -
> > -      if (args_type == MI_PRINT_ALL_VALUES)
> > -       should_print = 1;
> > -      else if (args_type == MI_PRINT_SIMPLE_VALUES
> > -              && type->code () != TYPE_CODE_ARRAY
> > -              && type->code () != TYPE_CODE_STRUCT
> > -              && type->code () != TYPE_CODE_UNION)
> > -       should_print = 1;
> > +    case NO_VALUES:
> > +      should_print = 0;
> > +      break;
> > +    default:
> > +    case MI_PRINT_ALL_VALUES:
> > +      should_print = 1;
> > +      break;
> > +    case MI_PRINT_SIMPLE_VALUES:
> > +      should_print = mi_print_type_p (value_type (val), PRINT_SIMPLE_VALUES);
> > +      break;
> > +    case MI_PRINT_SCALAR_VALUES:
> > +      should_print = mi_print_type_p (value_type (val), PRINT_SCALAR_VALUES);
> > +      break;
> >      }
> > -  else if (args_type != NO_VALUES)
> > -    should_print = 1;
> >
> >    if (should_print)
> >      {
> > @@ -371,10 +372,12 @@ py_print_single_arg (struct ui_out *out,
> >    if (print_args_field)
> >      out->field_signed ("arg", 1);
> >
> > -  /* For MI print the type, but only for simple values.  This seems
> > -     weird, but this is how MI choose to format the various output
> > +  /* For MI print the type, but only for simple and scalar values. This
> > +     seems weird, but this is how MI chooses to format the various output
> >       types.  */
> > -  if (args_type == MI_PRINT_SIMPLE_VALUES && val != NULL)
> > +  if ((args_type == MI_PRINT_SIMPLE_VALUES
> > +       || args_type == MI_PRINT_SCALAR_VALUES)
> > +      && val != NULL)
> >      py_print_type (out, val);
> >
> >    if (val != NULL)
> > @@ -603,7 +606,8 @@ enumerate_locals (PyObject *iter,
> >        out->field_string ("name", sym_name.get ());
> >        out->text (" = ");
> >
> > -      if (args_type == MI_PRINT_SIMPLE_VALUES)
> > +      if (args_type == MI_PRINT_SIMPLE_VALUES
> > +          || args_type == MI_PRINT_SCALAR_VALUES)
> >         py_print_type (out, val);
> >
> >        /* CLI always prints values for locals.  MI uses the
> > diff --git a/gdb/testsuite/gdb.mi/mi-stack.exp b/gdb/testsuite/gdb.mi/mi-stack.exp
> > index d04c8153c65..2c74da00c18 100644
> > --- a/gdb/testsuite/gdb.mi/mi-stack.exp
> > +++ b/gdb/testsuite/gdb.mi/mi-stack.exp
> > @@ -93,6 +93,11 @@ proc test_stack_args_listing {} {
> >      # -stack-list-arguments 1 1 1
> >      # -stack-list-arguments 1 1 3
> >      # -stack-list-arguments
> > +    # -stack-list-arguments 1 1 300
> > +    # -stack-list-arguments 2 1 1
> > +    # -stack-list-arguments --simple-values 1 1
> > +    # -stack-list-arguments 3 1 1
> > +    # -stack-list-arguments --scalar-values 1 1
> >
> >      mi_gdb_test "231-stack-list-arguments 0" \
> >         "231\\^done,stack-args=\\\[frame=\{level=\"0\",args=\\\[\\\]\},frame=\{level=\"1\",args=\\\[name=\"strarg\"\\\]\},frame=\{level=\"2\",args=\\\[name=\"intarg\",name=\"strarg\"\\\]\},frame=\{level=\"3\",args=\\\[name=\"intarg\",name=\"strarg\",name=\"fltarg\"\\\]\},frame=\{level=\"4\",args=\\\[\\\]\}\\\]" \
> > @@ -125,6 +130,22 @@ proc test_stack_args_listing {} {
> >      mi_gdb_test "235-stack-list-arguments 1 1 300" \
> >         "235\\^done,stack-args=\\\[frame=\{level=\"1\",args=\\\[\{name=\"strarg\",value=\"$hex \\\\\"A string argument.\\\\\"\"\}\\\]\},frame=\{level=\"2\",args=\\\[\{name=\"intarg\",value=\"2\"\},\{name=\"strarg\",value=\"$hex \\\\\"A string argument.\\\\\"\"\}\\\]\},frame=\{level=\"3\",args=\\\[\{name=\"intarg\",value=\"2\"\},\{name=\"strarg\",value=\"$hex \\\\\"A string argument.\\\\\"\"\},\{name=\"fltarg\",value=\"3.5\"\}\\\]\},frame=\{level=\"4\",args=\\\[\\\]\}\\\]" \
> >         "stack args listing 1 1 300"
> > +
> > +    mi_gdb_test "236-stack-list-arguments 2 1 1" \
> > +       "236\\^done,stack-args=\\\[frame=\\{level=\"1\",args=\\\[\\{name=\"strarg\",type=\"char \\*\",value=\"$hex \\\\\"A string argument.\\\\\"\"\\}\\\]\\}\\\]" \
> > +       "stack args listing 2 1 1"
> > +
> > +    mi_gdb_test "237-stack-list-arguments --simple-values 1 1" \
> > +       "237\\^done,stack-args=\\\[frame=\\{level=\"1\",args=\\\[\\{name=\"strarg\",type=\"char \\*\",value=\"$hex \\\\\"A string argument.\\\\\"\"\\}\\\]\\}\\\]" \
> > +       "stack args listing --simple-values 1 1"
> > +
> > +    mi_gdb_test "238-stack-list-arguments 3 1 1" \
> > +       "238\\^done,stack-args=\\\[frame=\\{level=\"1\",args=\\\[\\{name=\"strarg\",type=\"char \\*\",value=\"$hex \\\\\"A string argument.\\\\\"\"\\}\\\]\\}\\\]" \
> > +       "stack args listing 3 1 1"
> > +
> > +    mi_gdb_test "239-stack-list-arguments --scalar-values 1 1" \
> > +       "239\\^done,stack-args=\\\[frame=\\{level=\"1\",args=\\\[\\{name=\"strarg\",type=\"char \\*\",value=\"$hex \\\\\"A string argument.\\\\\"\"\\}\\\]\\}\\\]" \
> > +       "stack args listing --scalar-values 1 1"
> >  }
> >
> >  proc test_stack_info_depth {} {
> > @@ -163,7 +184,7 @@ proc test_stack_locals_listing {} {
> >      # -stack-list-locals 0 (--no-values)
> >      # -stack-list-locals 1 (--all-values)
> >      # -stack-list-locals 2 (--simple-values)
> > -    # -stack-list-arguments
> > +    # -stack-list-locals 3 (--scalar-values)
> >
> >      mi_gdb_test "232-stack-list-locals 0" \
> >         "232\\^done,locals=\\\[name=\"A\",name=\"B\",name=\"C\",name=\"D\"\\\]" \
> > @@ -179,10 +200,22 @@ proc test_stack_locals_listing {} {
> >         "232\\^done,locals=\\\[\{name=\"A\",value=\"1\"\},\{name=\"B\",value=\"2\"\},\{name=\"C\",value=\"3\"\},\{name=\"D\",value=\"\\{0, 1, 2\\}\"\}\\\]" \
> >         "stack locals listing of names and values"
> >
> > -    mi_gdb_test "232-stack-list-locals --simple-values" \
> > +    mi_gdb_test "232-stack-list-locals 2" \
> >         "232\\^done,locals=\\\[\{name=\"A\",type=\"int\",value=\"1\"\},\{name=\"B\",type=\"int\",value=\"2\"\},\{name=\"C\",type=\"int\",value=\"3\"\},\{name=\"D\",type=\"int \\\[3\\\]\"\}\\\]" \
> >         "stack locals listing, simple types: names and values, complex type: names and types"
> >
> > +    mi_gdb_test "232-stack-list-locals --simple-values" \
> > +       "232\\^done,locals=\\\[\\{name=\"A\",type=\"int\",value=\"1\"\\},\\{name=\"B\",type=\"int\",value=\"2\"\\},\\{name=\"C\",type=\"int\",value=\"3\"\\},\\{name=\"D\",type=\"int \\\[3\\\]\"\\}\\\]" \
> > +       "stack locals listing with --simple-values"
> > +
> > +    mi_gdb_test "233-stack-list-locals 3" \
> > +       "233\\^done,locals=\\\[\\{name=\"A\",type=\"int\",value=\"1\"\\},\\{name=\"B\",type=\"int\",value=\"2\"\\},\\{name=\"C\",type=\"int\",value=\"3\"\\},\\{name=\"D\",type=\"int \\\[3\\\]\"\\}\\\]" \
> > +       "stack locals listing, scalar types: names and values, otherwise: names and types"
> > +
> > +    mi_gdb_test "233-stack-list-locals --scalar-values" \
> > +       "233\\^done,locals=\\\[\\{name=\"A\",type=\"int\",value=\"1\"\\},\\{name=\"B\",type=\"int\",value=\"2\"\\},\\{name=\"C\",type=\"int\",value=\"3\"\\},\\{name=\"D\",type=\"int \\\[3\\\]\"\\}\\\]" \
> > +       "stack locals listing with --scalar-values"
> > +
> >      mi_gdb_test "234-stack-list-locals" \
> >         "234\\^error,msg=\"-stack-list-locals: Usage.*PRINT_VALUES.*\"" \
> >         "stack locals listing wrong"
> > diff --git a/gdb/testsuite/gdb.mi/print-values.cc b/gdb/testsuite/gdb.mi/print-values.cc
> > new file mode 100644
> > index 00000000000..b52683d1537
> > --- /dev/null
> > +++ b/gdb/testsuite/gdb.mi/print-values.cc
> > @@ -0,0 +1,63 @@
> > +/* This test case is part of GDB, the GNU debugger.
> > +
> > +   Copyright 2022 Free Software Foundation, Inc.
> > +
> > +   This program is free software; you can redistribute it and/or modify
> > +   it under the terms of the GNU General Public License as published by
> > +   the Free Software Foundation; either version 3 of the License, or
> > +   (at your option) any later version.
> > +
> > +   This program is distributed in the hope that it will be useful,
> > +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> > +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> > +   GNU General Public License for more details.
> > +
> > +   You should have received a copy of the GNU General Public License
> > +   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
> > +
> > +/* Test program for PRINT_SIMPLE_VALUES and PRINT_SCALAR_VALUES.
> > +
> > +   In the function f:
> > +
> > +   * The arguments i, ir, and irr are ints or references to ints,
> > +     which must be printed by both PRINT_SIMPLE_VALUES and
> > +     PRINT_SCALAR_VALUES.
> > +
> > +   * The arguments a, s, and u are non-scalar values, which must not
> > +     be printed by either PRINT_SIMPLE_VALUES or PRINT_SCALAR_VALUES.
> > +
> > +   * The arguments ar, arr, sr, srr, ur, and urr are references to
> > +     non-scalar values, which must be printed by PRINT_SIMPLE_VALUES
> > +     but not printed by PRINT_SCALAR_VALUES.  */
> > +
> > +struct s
> > +{
> > +  int v;
> > +};
> > +
> > +union u
> > +{
> > +  int v;
> > +};
> > +
> > +int
> > +f (int i, int &ir, int &&irr,
> > +   int a[1], int (&ar)[1], int (&&arr)[1],
> > +   struct s s, struct s &sr, struct s &&srr,
> > +   union u u, union u &ur, union u &&urr)
> > +{
> > +  return (i + ir + irr
> > +          + a[0] + ar[0] + arr[0]
> > +          + s.v + sr.v + srr.v
> > +          + u.v + ur.v + urr.v);
> > +}
> > +
> > +int
> > +main (void)
> > +{
> > +  int i = 1, j = 2;
> > +  int a[1] = { 4 }, b[1] = { 5 };
> > +  struct s s = { 7 }, t = { 8 };
> > +  union u u = { 10 }, v = { 11 };
> > +  return f (i, j, 3, a, b, { 6 }, s, t, { 9 }, u, v, { 12 });
> > +}
> > diff --git a/gdb/testsuite/gdb.mi/print-values.exp b/gdb/testsuite/gdb.mi/print-values.exp
> > new file mode 100644
> > index 00000000000..7896d773119
> > --- /dev/null
> > +++ b/gdb/testsuite/gdb.mi/print-values.exp
> > @@ -0,0 +1,53 @@
> > +# Copyright 2022 Free Software Foundation, Inc.
> > +#
> > +# This program is free software; you can redistribute it and/or modify
> > +# it under the terms of the GNU General Public License as published by
> > +# the Free Software Foundation; either version 3 of the License, or
> > +# (at your option) any later version.
> > +#
> > +# This program is distributed in the hope that it will be useful,
> > +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> > +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> > +# GNU General Public License for more details.
> > +#
> > +# You should have received a copy of the GNU General Public License
> > +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
> > +
> > +# Test of PRINT_SIMPLE_VALUES and PRINT_SCALAR_VALUES.
> > +#
> > +# Test that PRINT_SIMPLE_VALUES distinguishes scalar and non-scalar
> > +# types, except for C++ reference and rvalue reference types.
> > +#
> > +# Test that PRINT_SCALAR_VALUES distinguishes scalar and non-scalar
> > +# types, including C++ reference and rvalue reference types.
> > +
> > +if { [skip_cplus_tests] } { continue }
> > +
> > +load_lib mi-support.exp
> > +standard_testfile .cc
> > +
> > +if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile executable {debug c++}] != "" } {
> > +    untested "failed to compile"
> > +    return -1
> > +}
> > +
> > +mi_clean_restart $binfile
> > +
> > +mi_runto_main
> > +
> > +mi_gdb_test "-break-insert f" "\\^done.*" "set breakpoint on f"
> > +
> > +mi_send_resuming_command "exec-continue" "exec-continue to breakpoint on f"
> > +
> > +mi_expect_stop "breakpoint-hit" "f" ".*" ".*" ".*" {.* disp="keep"} \
> > +    "run until breakpoint on f"
> > +
> > +mi_gdb_test "-stack-list-arguments --simple-values" \
> > +    "\\^done,stack-args=\\\[frame=\\{level=\"0\",args=\\\[\\{name=\"i\",type=\"int\",value=\"1\"\\},\\{name=\"ir\",type=\"int &\",value=\"@$hex: 2\"\\},\\{name=\"irr\",type=\"int &&\",value=\"@$hex: 3\"\\},\\{name=\"a\",type=\"int \\*\",value=\"$hex\"\\},\\{name=\"ar\",type=\"int \\(&\\)\\\[1\\\]\",value=\"@$hex: \\{5\\}\"\\},\\{name=\"arr\",type=\"int \\(&&\\)\\\[1\\\]\",value=\"@$hex: \\{6\\}\"\\},\\{name=\"s\",type=\"s\"\\},\\{name=\"sr\",type=\"s &\",value=\"@$hex: \\{v = 8\\}\"\\},\\{name=\"srr\",type=\"s &&\",value=\"@$hex: \\{v = 9\\}\"\\},\\{name=\"u\",type=\"u\"\\},\\{name=\"ur\",type=\"u &\",value=\"@$hex: \\{v = 11\\}\"\\},\\{name=\"urr\",type=\"u &&\",value=\"@$hex: \\{v = 12\\}\"\\}\\\]\\},frame=\\{level=\"1\",args=\\\[\\\]\\}\\\]" \
> > +    "stack list arguments, simple types: names, types and values, otherwise: names and types"
> > +
> > +mi_gdb_test "-stack-list-arguments --scalar-values" \
> > +    "\\^done,stack-args=\\\[frame=\\{level=\"0\",args=\\\[\\{name=\"i\",type=\"int\",value=\"1\"\\},\\{name=\"ir\",type=\"int &\",value=\"@$hex: 2\"\\},\\{name=\"irr\",type=\"int &&\",value=\"@$hex: 3\"\\},\\{name=\"a\",type=\"int \\*\",value=\"$hex\"\\},\\{name=\"ar\",type=\"int \\(&\\)\\\[1\\\]\"\\},\\{name=\"arr\",type=\"int \\(&&\\)\\\[1\\\]\"\\},\\{name=\"s\",type=\"s\"\\},\\{name=\"sr\",type=\"s &\"\\},\\{name=\"srr\",type=\"s &&\"\\},\\{name=\"u\",type=\"u\"\\},\\{name=\"ur\",type=\"u &\"\\},\\{name=\"urr\",type=\"u &&\"\\}\\\]\\},frame=\\{level=\"1\",args=\\\[\\\]\\}\\\]" \
> > +    "stack list arguments, scalar types: names, types and values, compound types: names and types"
> > +
> > +mi_gdb_exit
> > diff --git a/gdb/testsuite/gdb.python/py-framefilter-mi.exp b/gdb/testsuite/gdb.python/py-framefilter-mi.exp
> > index 344067fe4a7..fa4e559e343 100644
> > --- a/gdb/testsuite/gdb.python/py-framefilter-mi.exp
> > +++ b/gdb/testsuite/gdb.python/py-framefilter-mi.exp
> > @@ -120,6 +120,14 @@ mi_gdb_test "-stack-list-arguments --no-frame-filters 2" \
> >      "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
> >      "stack-list-arguments --no-frame-filters 2"
> >
> > +mi_gdb_test "-stack-list-arguments 3" \
> > +    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"\}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
> > +    "stack-list-arguments 3"
> > +
> > +mi_gdb_test "-stack-list-arguments --no-frame-filters 3" \
> > +    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
> > +    "stack-list-arguments --no-frame-filters 3"
> > +
> >
> >  mi_gdb_test "-stack-list-arguments 2 0 3" \
> >      "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},frame={level=\"3\",args=\\\[\\\]}\\\]" \
> > @@ -133,6 +141,14 @@ mi_gdb_test "-stack-list-arguments --no-frame-filters 2 22 27" \
> >      "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\]},frame={level=\"23\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
> >      "stack-list-arguments --no-frame-filters 2 22 27"
> >
> > +mi_gdb_test "-stack-list-arguments 3 22 27" \
> > +    "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
> > +    "stack-list-arguments 3 22 27"
> > +
> > +mi_gdb_test "-stack-list-arguments --no-frame-filters 3 22 27" \
> > +    "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\]},frame={level=\"23\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
> > +    "stack-list-arguments --no-frame-filters 3 22 27"
> > +
> >  #stack-list-locals
> >  mi_gdb_test "-stack-list-locals --no-frame-filters 0" \
> >      "\\^done,locals=\\\[name=\"str\",name=\"st2\",name=\"b\",name=\"c\"\\\]" \
> > @@ -146,6 +162,10 @@ mi_gdb_test "-stack-list-locals --no-frame-filters 2" \
> >      "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
> >      "stack-list-locals --no-frame-filters 2"
> >
> > +mi_gdb_test "-stack-list-locals --no-frame-filters 3" \
> > +    "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
> > +    "stack-list-locals --no-frame-filters 3"
> > +
> >  mi_gdb_test "-stack-list-locals --no-frame-filters --no-values" \
> >      "\\^done,locals=\\\[name=\"str\",name=\"st2\",name=\"b\",name=\"c\"\\\]" \
> >      "stack-list-locals --no-frame-filters --no-values"
> > @@ -158,6 +178,10 @@ mi_gdb_test "-stack-list-locals --no-frame-filters --simple-values" \
> >      "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
> >      "stack-list-locals --no-frame-filters --simple-values"
> >
> > +mi_gdb_test "-stack-list-locals --no-frame-filters --scalar-values" \
> > +    "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
> > +    "stack-list-locals --no-frame-filters --scalar-values"
> > +
> >  mi_gdb_test "-stack-list-locals 0" \
> >      "\\^done,locals=\\\[name=\"str\",name=\"st2\",name=\"b\",name=\"c\"\\\]" \
> >      "stack-list-locals 0"
> > @@ -170,6 +194,10 @@ mi_gdb_test "-stack-list-locals 2" \
> >      "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
> >      "stack-list-locals 2"
> >
> > +mi_gdb_test "-stack-list-locals 3" \
> > +    "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
> > +    "stack-list-locals 3"
> > +
> >  # stack-list-variables
> >  mi_gdb_test "-stack-list-variables --no-frame-filters 0" \
> >      "\\^done,variables=\\\[{name=\"foo\",arg=\"1\"},{name=\"bar\",arg=\"1\"},{name=\"fb\",arg=\"1\"},{name=\"bf\",arg=\"1\"},{name=\"str\"},{name=\"st2\"},{name=\"b\"},{name=\"c\"}\\\]" \
> > --
> > 2.26.0
> >

  parent reply	other threads:[~2022-12-01 13:41 UTC|newest]

Thread overview: 49+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2022-09-08  7:18 [PATCH] [gdb/mi] Don't treat references to compound values as "simple" Gareth Rees
2022-09-08 10:27 ` Andrew Burgess
2022-09-08 11:02   ` [PATCH v2] " Gareth Rees
2022-09-08 13:30     ` Eli Zaretskii
2022-09-08 13:58       ` Gareth Rees
2022-09-08 14:07         ` Eli Zaretskii
2022-09-09  8:01       ` [PATCH v3] [PR mi/29554] New PRINT-VALUES option '--scalar-values' Gareth Rees
2022-09-15  9:06         ` [PING] " Gareth Rees
2022-09-25  8:15         ` Gareth Rees
2022-09-25  8:25           ` Eli Zaretskii
2022-09-25  9:00             ` Gareth Rees
2022-09-25 10:16               ` Eli Zaretskii
2022-09-26 12:48                 ` Gareth Rees
2022-09-25 10:16           ` Eli Zaretskii
2022-09-26 12:46         ` [PATCH v4] " Gareth Rees
2022-10-04  9:08           ` [PING] " Gareth Rees
2022-10-18 11:59             ` Gareth Rees
2022-10-12 16:38           ` Andrew Burgess
2022-10-20 17:47             ` [PATCH v5] " Gareth Rees
2022-10-20 18:00               ` Eli Zaretskii
2022-11-03 16:20               ` [PING] " Gareth Rees
2022-11-14  9:25                 ` Gareth Rees
2022-12-01 13:41                 ` Gareth Rees [this message]
2022-12-14  8:50                 ` Gareth Rees
2023-02-01 10:00                 ` Gareth Rees
2023-02-16 10:08                 ` Gareth Rees
2023-03-06  9:52                 ` Gareth Rees
2023-03-08 12:35               ` Andrew Burgess
2023-03-10 11:04                 ` Gareth Rees
2023-03-10 12:05                   ` Eli Zaretskii
2023-03-10 12:58                     ` Gareth Rees
2023-03-13 17:17                     ` Andrew Burgess
2023-03-16 12:28                       ` Gareth Rees
2023-03-11 11:58                   ` Gareth Rees
2023-04-11 13:15                     ` Pedro Alves
2023-03-11 11:49               ` [PATCH v6] [gdb/mi] Don't treat references to compound values as "simple" Gareth Rees
2023-03-21  9:50                 ` [PING] " Gareth Rees
2023-03-26  9:56                   ` Gareth Rees
2023-04-03  9:22                     ` Gareth Rees
2023-05-04 15:08                       ` Tom Tromey
2023-04-18  9:23                   ` Gareth Rees
2023-04-24  9:53                   ` Gareth Rees
2023-05-02  9:13                   ` Gareth Rees
2023-03-27 14:34                 ` Tom Tromey
2023-03-29  9:14                   ` Gareth Rees
2023-04-06 17:18                   ` Gareth Rees
2022-10-20 17:58             ` [PATCH v4] [PR mi/29554] New PRINT-VALUES option '--scalar-values' Gareth Rees
2022-09-09  8:04       ` [PATCH v2] [gdb/mi] Don't treat references to compound values as "simple" Gareth Rees
2022-09-08 11:09   ` [PATCH] " Gareth Rees

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to='CAA8DSpFwdYGSDSECp741VwC5Prjw=3EZ7COLchRxbYeZjFxUbw@mail.gmail.com' \
    --to=grees@undo.io \
    --cc=gdb-patches@sourceware.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).