mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-15 04:31:49 +08:00
Code Issues Packages Projects Releases Wiki Activity
3017b94d60
binutils-gdb/gdb/valprint.h
Andrew Burgess 2e62ab400f gdb: Introduce 'print max-depth' feature 
Introduce a new print setting max-depth which can be set with 'set
print max-depth DEPTH'.  The default value of DEPTH is 20, but this
can also be set to unlimited.

When GDB is printing a value containing nested structures GDB will
stop descending at depth DEPTH.  Here is a small example:

    typedef struct s1 { int a; } s1;
    typedef struct s2 { s1 b; } s2;
    typedef struct s3 { s2 c; } s3;
    typedef struct s4 { s3 d; } s4;

    s4 var = { { { { 3 } } } };

The following table shows how various depth settings affect printing
of 'var':

    | Depth Setting | Result of 'p var'              |
    |---------------+--------------------------------|
    |     Unlimited | $1 = {d = {c = {b = {a = 3}}}} |
    |             4 | $1 = {d = {c = {b = {a = 3}}}} |
    |             3 | $1 = {d = {c = {b = {...}}}}   |
    |             2 | $1 = {d = {c = {...}}}         |
    |             1 | $1 = {d = {...}}               |
    |             0 | $1 = {...}                     |

Only structures, unions, and arrays are replaced in this way, scalars
and strings are not replaced.

The replacement is counted from the level at which you print, not from
the top level of the structure.  So, consider the above example and
this GDB session:

    (gdb) set print max-depth 2
    (gdb) p var
    $1 = {d = {c = {...}}}
    (gdb) p var.d
    $2 = {c = {b = {...}}}
    (gdb) p var.d.c
    $3 = {b = {a = 3}}

Setting the max-depth to 2 doesn't prevent the user from exploring
deeper into 'var' by asking for specific sub-fields to be printed.

The motivation behind this feature is to try and give the user more
control over how much is printed when examining large, complex data
structures.

The default max-depth of 20 means that there is a change in GDB's
default behaviour.  Someone printing a data structure with 20 levels
of nesting will now see '{...}' instead of their data, they would need
to adjust the max depth, or call print again naming a specific field
in order to dig deeper into their data structure.  If this is
considered a problem then we could increase the default, or even make
the default unlimited.

This commit relies on the previous commit, which added a new field to
the language structure, this new field was a string that contained the
pattern that should be used when a structure/union/array is replaced
in the output, this allows languages to use a syntax that is more
appropriate, mostly this will be selecting the correct types of
bracket '(...)' or '{...}', both of which are currently in use.

This commit should have no impact on MI output, expressions are
printed through the MI using -var-create and then -var-list-children.
As each use of -var-list-children only ever displays a single level of
an expression then the max-depth setting will have no impact.

This commit also adds the max-depth mechanism to the scripting
language pretty printers following basically the same rules as for the
built in value printing.

One quirk is that when printing a value using the display hint 'map',
if the keys of the map are structs then GDB will hide the keys one
depth level after it hides the values, this ensures that GDB produces
output like this:

  $1 = map_object = {[{key1}] = {...}, [{key2}] = {...}}

Instead of this less helpful output:

  $1 = map_object = {[{...}] = {...}, [{...}] = {...}}

This is covered by the new tests in gdb.python/py-nested-maps.exp.

gdb/ChangeLog:

	* cp-valprint.c (cp_print_value_fields): Allow an additional level
	of depth when printing anonymous structs or unions.
	* guile/scm-pretty-print.c (gdbscm_apply_val_pretty_printer):
	Don't print either the top-level value, or the children if the
	max-depth is exceeded.
	(ppscm_print_children): When printing the key of a map, allow one
	extra level of depth.
	* python/py-prettyprint.c (gdbpy_apply_val_pretty_printer): Don't
	print either the top-level value, or the children if the max-depth
	is exceeded.
	(print_children): When printing the key of a map, allow one extra
	level of depth.
	* python/py-value.c (valpy_format_string): Add max_depth keyword.
	* valprint.c: (PRINT_MAX_DEPTH_DEFAULT): Define.
	(user_print_options): Initialise max_depth field.
	(val_print_scalar_or_string_type_p): New function.
	(val_print): Check to see if the max depth has been reached.
	(val_print_check_max_depth): Define new function.
	(show_print_max_depth): New function.
	(_initialize_valprint): Add 'print max-depth' option.
	* valprint.h (struct value_print_options) <max_depth>: New field.
	(val_print_check_max_depth): Declare new function.
	* NEWS: Document new feature.

gdb/doc/ChangeLog:

	* gdb.texinfo (Print Settings): Document 'print max-depth'.
	* guile.texi (Guile Pretty Printing API): Document that 'print
	max-depth' can effect the display of a values children.
	* python.texi (Pretty Printing API): Likewise.
	(Values From Inferior): Document max_depth keyword.

gdb/testsuite/ChangeLog:

	* gdb.base/max-depth.c: New file.
	* gdb.base/max-depth.exp: New file.
	* gdb.python/py-nested-maps.c: New file.
	* gdb.python/py-nested-maps.exp: New file.
	* gdb.python/py-nested-maps.py: New file.
	* gdb.python/py-format-string.exp (test_max_depth): New proc.
	(test_all_common): Call test_max_depth.
	* gdb.fortran/max-depth.exp: New file.
	* gdb.fortran/max-depth.f90: New file.
	* gdb.go/max-depth.exp: New file.
	* gdb.go/max-depth.go: New file.
	* gdb.modula2/max-depth.exp: New file.
	* gdb.modula2/max-depth.c: New file.
	* lib/gdb.exp (get_print_expr_at_depths): New proc.
2019-04-29 22:01:09 +01:00

262 lines
8.5 KiB
C++
Raw Blame History

/* Declarations for value printing routines for GDB, the GNU debugger.
Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
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/>. */
#ifndef VALPRINT_H
#define VALPRINT_H
/* This is used to pass formatting options to various value-printing
functions. */
struct value_print_options
{
/* Pretty-formatting control. */
enum val_prettyformat prettyformat;
/* Controls pretty formatting of arrays. */
int prettyformat_arrays;
/* Controls pretty formatting of structures. */
int prettyformat_structs;
/* Controls printing of virtual tables. */
int vtblprint;
/* Controls printing of nested unions. */
int unionprint;
/* Controls printing of addresses. */
int addressprint;
/* Controls looking up an object's derived type using what we find
in its vtables. */
int objectprint;
/* Maximum number of chars to print for a string pointer value or vector
contents, or UINT_MAX for no limit. Note that "set print elements 0"
stores UINT_MAX in print_max, which displays in a show command as
"unlimited". */
unsigned int print_max;
/* Print repeat counts if there are more than this many repetitions
of an element in an array. */
unsigned int repeat_count_threshold;
/* The global output format letter. */
int output_format;
/* The current format letter. This is set locally for a given call,
e.g. when the user passes a format to "print". */
int format;
/* Stop printing at null character? */
int stop_print_at_null;
/* True if we should print the index of each element when printing
an array. */
int print_array_indexes;
/* If nonzero, then dereference references, otherwise just print
them like pointers. */
int deref_ref;
/* If nonzero, print static fields. */
int static_field_print;
/* If nonzero, print static fields for Pascal. FIXME: C++ has a
flag, why not share with Pascal too? */
int pascal_static_field_print;
/* If non-zero don't do Python pretty-printing. */
int raw;
/* If nonzero, print the value in "summary" form.
If raw and summary are both non-zero, don't print non-scalar values
("..." is printed instead). */
int summary;
/* If nonzero, when printing a pointer, print the symbol to which it
points, if any. */
int symbol_print;
/* Maximum print depth when printing nested aggregates. */
int max_depth;
};
/* The global print options set by the user. In general this should
not be directly accessed, except by set/show commands. Ordinary
code should call get_user_print_options instead. */
extern struct value_print_options user_print_options;
/* Initialize *OPTS to be a copy of the user print options. */
extern void get_user_print_options (struct value_print_options *opts);
/* Initialize *OPTS to be a copy of the user print options, but with
pretty-formatting disabled. */
extern void get_no_prettyformat_print_options (struct value_print_options *);
/* Initialize *OPTS to be a copy of the user print options, but using
FORMAT as the formatting option. */
extern void get_formatted_print_options (struct value_print_options *opts,
char format);
extern void maybe_print_array_index (struct type *index_type, LONGEST index,
struct ui_file *stream,
const struct value_print_options *);
extern void val_print_array_elements (struct type *, LONGEST,
CORE_ADDR, struct ui_file *, int,
struct value *,
const struct value_print_options *,
unsigned int);
extern void val_print_scalar_formatted (struct type *,
LONGEST,
struct value *,
const struct value_print_options *,
int,
struct ui_file *);
extern void print_binary_chars (struct ui_file *, const gdb_byte *,
unsigned int, enum bfd_endian, bool);
extern void print_octal_chars (struct ui_file *, const gdb_byte *,
unsigned int, enum bfd_endian);
extern void print_decimal_chars (struct ui_file *, const gdb_byte *,
unsigned int, bool, enum bfd_endian);
extern void print_hex_chars (struct ui_file *, const gdb_byte *,
unsigned int, enum bfd_endian, bool);
extern void print_char_chars (struct ui_file *, struct type *,
const gdb_byte *, unsigned int, enum bfd_endian);
extern void print_function_pointer_address (const struct value_print_options *options,
struct gdbarch *gdbarch,
CORE_ADDR address,
struct ui_file *stream);
extern int read_string (CORE_ADDR addr, int len, int width,
unsigned int fetchlimit,
enum bfd_endian byte_order,
gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
int *bytes_read);
extern void val_print_optimized_out (const struct value *val,
struct ui_file *stream);
/* Prints "<not saved>" to STREAM. */
extern void val_print_not_saved (struct ui_file *stream);
extern void val_print_unavailable (struct ui_file *stream);
extern void val_print_invalid_address (struct ui_file *stream);
/* An instance of this is passed to generic_val_print and describes
some language-specific ways to print things. */
struct generic_val_print_decorations
{
/* Printing complex numbers: what to print before, between the
elements, and after. */
const char *complex_prefix;
const char *complex_infix;
const char *complex_suffix;
/* Boolean true and false. */
const char *true_name;
const char *false_name;
/* What to print when we see TYPE_CODE_VOID. */
const char *void_name;
/* Array start and end strings. */
const char *array_start;
const char *array_end;
};
extern void generic_val_print (struct type *type,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options,
const struct generic_val_print_decorations *);
extern void generic_emit_char (int c, struct type *type, struct ui_file *stream,
int quoter, const char *encoding);
extern void generic_printstr (struct ui_file *stream, struct type *type,
const gdb_byte *string, unsigned int length,
const char *encoding, int force_ellipses,
int quote_char, int c_style_terminator,
const struct value_print_options *options);
/* Run the "output" command. ARGS and FROM_TTY are the usual
arguments passed to all command implementations, except ARGS is
const. */
extern void output_command (const char *args, int from_tty);
extern int val_print_scalar_type_p (struct type *type);
struct format_data
{
int count;
char format;
char size;
/* True if the value should be printed raw -- that is, bypassing
python-based formatters. */
unsigned char raw;
};
extern void print_command_parse_format (const char **expp, const char *cmdname,
struct format_data *fmtp);
extern void print_value (struct value *val, const struct format_data *fmtp);
/* Given an address ADDR return all the elements needed to print the
address in a symbolic form. NAME can be mangled or not depending
on DO_DEMANGLE (and also on the asm_demangle global variable,
manipulated via ''set print asm-demangle''). Return 0 in case of
success, when all the info in the OUT paramters is valid. Return 1
otherwise. */
extern int build_address_symbolic (struct gdbarch *,
CORE_ADDR addr,
int do_demangle,
std::string *name,
int *offset,
std::string *filename,
int *line,
int *unmapped);
/* Check to see if RECURSE is greater than or equal to the allowed
printing max-depth (see 'set print max-depth'). If it is then print an
ellipsis expression to STREAM and return true, otherwise return false.
LANGUAGE determines what type of ellipsis expression is printed. */
extern bool val_print_check_max_depth (struct ui_file *stream, int recurse,
const struct value_print_options *opts,
const struct language_defn *language);
#endif
Reference in New Issue View Git Blame Copy Permalink