gdb/valprint.h

   1 /* Declarations for value printing routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2023 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef VALPRINT_H
  21 #define VALPRINT_H
  22
  23 #include "cli/cli-option.h"
  24
  25 /* This is used to pass formatting options to various value-printing
  26    functions.  */
  27 struct value_print_options
  28 {
  29   /* Pretty-formatting control.  */
  30   enum val_prettyformat prettyformat;
  31
  32   /* Controls pretty formatting of arrays.  */
  33   bool prettyformat_arrays;
  34
  35   /* Controls pretty formatting of structures.  */
  36   bool prettyformat_structs;
  37
  38   /* Controls printing of virtual tables.  */
  39   bool vtblprint;
  40
  41   /* Controls printing of nested unions.  */
  42   bool unionprint;
  43
  44   /* Controls printing of addresses.  */
  45   bool addressprint;
  46
  47   /* Controls printing of nibbles.  */
  48   bool nibblesprint;
  49
  50   /* Controls looking up an object's derived type using what we find
  51      in its vtables.  */
  52   bool objectprint;
  53
  54   /* Maximum number of elements to print for vector contents, or UINT_MAX
  55      for no limit.  Note that "set print elements 0" stores UINT_MAX in
  56      print_max, which displays in a show command as "unlimited".  */
  57   unsigned int print_max;
  58
  59   /* Maximum number of string chars to print for a string pointer value,
  60      zero if to follow the value of print_max, or UINT_MAX for no limit.  */
  61   unsigned int print_max_chars;
  62
  63   /* Print repeat counts if there are more than this many repetitions
  64      of an element in an array.  */
  65   unsigned int repeat_count_threshold;
  66
  67   /* The global output format letter.  */
  68   int output_format;
  69
  70   /* The current format letter.  This is set locally for a given call,
  71      e.g. when the user passes a format to "print".  */
  72   int format;
  73
  74   /* Print memory tag violations for pointers.  */
  75   bool memory_tag_violations;
  76
  77   /* Stop printing at null character?  */
  78   bool stop_print_at_null;
  79
  80   /* True if we should print the index of each element when printing
  81      an array.  */
  82   bool print_array_indexes;
  83
  84   /* If true, then dereference references, otherwise just print
  85      them like pointers.  */
  86   bool deref_ref;
  87
  88   /* If true, print static fields.  */
  89   bool static_field_print;
  90
  91   /* If true, print static fields for Pascal.  FIXME: C++ has a
  92      flag, why not share with Pascal too?  */
  93   bool pascal_static_field_print;
  94
  95   /* If true, don't do Python pretty-printing.  */
  96   bool raw;
  97
  98   /* If true, print the value in "summary" form.
  99      If raw and summary are both true, don't print non-scalar values
 100      ("..." is printed instead).  */
 101   bool summary;
 102
 103   /* If true, when printing a pointer, print the symbol to which it
 104      points, if any.  */
 105   bool symbol_print;
 106
 107   /* Maximum print depth when printing nested aggregates.  */
 108   int max_depth;
 109 };
 110
 111 /* The value to use for `print_max_chars' to follow `print_max'.  */
 112 #define PRINT_MAX_CHARS_ELEMENTS 0
 113
 114 /* The value to use for `print_max_chars' for no limit.  */
 115 #define PRINT_MAX_CHARS_UNLIMITED UINT_MAX
 116
 117 /* Return the character count limit for printing strings.  */
 118
 119 static inline unsigned int
 120 get_print_max_chars (const struct value_print_options *options)
 121 {
 122   return (options->print_max_chars != PRINT_MAX_CHARS_ELEMENTS
 123           ? options->print_max_chars : options->print_max);
 124 }
 125
 126 /* Create an option_def_group for the value_print options, with OPTS
 127    as context.  */
 128 extern gdb::option::option_def_group make_value_print_options_def_group
 129   (value_print_options *opts);
 130
 131 /* The global print options set by the user.  In general this should
 132    not be directly accessed, except by set/show commands.  Ordinary
 133    code should call get_user_print_options instead.  */
 134 extern struct value_print_options user_print_options;
 135
 136 /* Initialize *OPTS to be a copy of the user print options.  */
 137 extern void get_user_print_options (struct value_print_options *opts);
 138
 139 /* Initialize *OPTS to be a copy of the user print options, but with
 140    pretty-formatting disabled.  */
 141 extern void get_no_prettyformat_print_options (struct value_print_options *);
 142
 143 /* Initialize *OPTS to be a copy of the user print options, but using
 144    FORMAT as the formatting option.  */
 145 extern void get_formatted_print_options (struct value_print_options *opts,
 146                                          char format);
 147
 148 extern void maybe_print_array_index (struct type *index_type, LONGEST index,
 149                                      struct ui_file *stream,
 150                                      const struct value_print_options *);
 151
 152
 153 /* Print elements of an array.  */
 154
 155 extern void value_print_array_elements (struct value *, struct ui_file *, int,
 156                                         const struct value_print_options *,
 157                                         unsigned int);
 158
 159 /* Print a scalar according to OPTIONS and SIZE on STREAM.  Format 'i'
 160    is not supported at this level.
 161
 162    This is how the elements of an array or structure are printed
 163    with a format.  */
 164
 165 extern void value_print_scalar_formatted
 166   (struct value *val, const struct value_print_options *options,
 167    int size, struct ui_file *stream);
 168
 169 extern void print_binary_chars (struct ui_file *, const gdb_byte *,
 170                                 unsigned int, enum bfd_endian, bool,
 171                                 const struct value_print_options *options);
 172
 173 extern void print_octal_chars (struct ui_file *, const gdb_byte *,
 174                                unsigned int, enum bfd_endian);
 175
 176 extern void print_decimal_chars (struct ui_file *, const gdb_byte *,
 177                                  unsigned int, bool, enum bfd_endian);
 178
 179 extern void print_hex_chars (struct ui_file *, const gdb_byte *,
 180                              unsigned int, enum bfd_endian, bool);
 181
 182 extern void print_function_pointer_address (const struct value_print_options *options,
 183                                             struct gdbarch *gdbarch,
 184                                             CORE_ADDR address,
 185                                             struct ui_file *stream);
 186
 187 /* Helper function to check the validity of some bits of a value.
 188
 189    If TYPE represents some aggregate type (e.g., a structure), return 1.
 190
 191    Otherwise, any of the bytes starting at OFFSET and extending for
 192    TYPE->length () bytes are invalid, print a message to STREAM and
 193    return 0.  The checking is done using FUNCS.
 194
 195    Otherwise, return 1.  */
 196
 197 extern int valprint_check_validity (struct ui_file *stream, struct type *type,
 198                                     LONGEST embedded_offset,
 199                                     const struct value *val);
 200
 201 extern void val_print_optimized_out (const struct value *val,
 202                                      struct ui_file *stream);
 203
 204 /* Prints "<not saved>" to STREAM.  */
 205 extern void val_print_not_saved (struct ui_file *stream);
 206
 207 extern void val_print_unavailable (struct ui_file *stream);
 208
 209 extern void val_print_invalid_address (struct ui_file *stream);
 210
 211 /* An instance of this is passed to generic_val_print and describes
 212    some language-specific ways to print things.  */
 213
 214 struct generic_val_print_decorations
 215 {
 216   /* Printing complex numbers: what to print before, between the
 217      elements, and after.  */
 218
 219   const char *complex_prefix;
 220   const char *complex_infix;
 221   const char *complex_suffix;
 222
 223   /* Boolean true and false.  */
 224
 225   const char *true_name;
 226   const char *false_name;
 227
 228   /* What to print when we see TYPE_CODE_VOID.  */
 229
 230   const char *void_name;
 231
 232   /* Array start and end strings.  */
 233   const char *array_start;
 234   const char *array_end;
 235 };
 236
 237
 238 /* Print a value in a generic way.  VAL is the value, STREAM is where
 239    to print it, RECURSE is the recursion depth, OPTIONS describe how
 240    the printing should be done, and D is the language-specific
 241    decorations object.  Note that structs and unions cannot be printed
 242    by this function.  */
 243
 244 extern void generic_value_print (struct value *val, struct ui_file *stream,
 245                                  int recurse,
 246                                  const struct value_print_options *options,
 247                                  const struct generic_val_print_decorations *d);
 248
 249 extern void generic_emit_char (int c, struct type *type, struct ui_file *stream,
 250                                int quoter, const char *encoding);
 251
 252 extern void generic_printstr (struct ui_file *stream, struct type *type,
 253                               const gdb_byte *string, unsigned int length,
 254                               const char *encoding, int force_ellipses,
 255                               int quote_char, int c_style_terminator,
 256                               const struct value_print_options *options);
 257
 258 /* Run the "output" command.  ARGS and FROM_TTY are the usual
 259    arguments passed to all command implementations, except ARGS is
 260    const.  */
 261
 262 extern void output_command (const char *args, int from_tty);
 263
 264 extern int val_print_scalar_type_p (struct type *type);
 265
 266 struct format_data
 267   {
 268     int count;
 269     char format;
 270     char size;
 271     bool print_tags;
 272
 273     /* True if the value should be printed raw -- that is, bypassing
 274        python-based formatters.  */
 275     unsigned char raw;
 276   };
 277
 278 extern void print_command_parse_format (const char **expp, const char *cmdname,
 279                                         value_print_options *opts);
 280
 281 /* Print VAL to console according to OPTS, including recording it to
 282    the history.  */
 283 extern void print_value (value *val, const value_print_options &opts);
 284
 285 /* Completer for the "print", "call", and "compile print"
 286    commands.  */
 287 extern void print_command_completer (struct cmd_list_element *ignore,
 288                                      completion_tracker &tracker,
 289                                      const char *text, const char *word);
 290
 291 /* Given an address ADDR return all the elements needed to print the
 292    address in a symbolic form.  NAME can be mangled or not depending
 293    on DO_DEMANGLE (and also on the asm_demangle global variable,
 294    manipulated via ''set print asm-demangle'').  When
 295    PREFER_SYM_OVER_MINSYM is true, names (and offsets) from minimal
 296    symbols won't be used except in instances where no symbol was
 297    found; otherwise, a minsym might be used in some instances (mostly
 298    involving function with non-contiguous address ranges).  Return
 299    0 in case of success, when all the info in the OUT parameters is
 300    valid.  Return 1 otherwise.  */
 301
 302 extern int build_address_symbolic (struct gdbarch *,
 303                                    CORE_ADDR addr,
 304                                    bool do_demangle,
 305                                    bool prefer_sym_over_minsym,
 306                                    std::string *name,
 307                                    int *offset,
 308                                    std::string *filename,
 309                                    int *line,
 310                                    int *unmapped);
 311
 312 /* Check to see if RECURSE is greater than or equal to the allowed
 313    printing max-depth (see 'set print max-depth').  If it is then print an
 314    ellipsis expression to STREAM and return true, otherwise return false.
 315    LANGUAGE determines what type of ellipsis expression is printed.  */
 316
 317 extern bool val_print_check_max_depth (struct ui_file *stream, int recurse,
 318                                        const struct value_print_options *opts,
 319                                        const struct language_defn *language);
 320
 321 /* Like common_val_print, but call value_check_printable first.  */
 322
 323 extern void common_val_print_checked
 324   (struct value *val,
 325    struct ui_file *stream, int recurse,
 326    const struct value_print_options *options,
 327    const struct language_defn *language);
 328
 329 #endif