gdb/valprint.h

   1 /* Declarations for value printing routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2020 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 looking up an object's derived type using what we find
  48      in its vtables.  */
  49   bool objectprint;
  50
  51   /* Maximum number of chars to print for a string pointer value or vector
  52      contents, or UINT_MAX for no limit.  Note that "set print elements 0"
  53      stores UINT_MAX in print_max, which displays in a show command as
  54      "unlimited".  */
  55   unsigned int print_max;
  56
  57   /* Print repeat counts if there are more than this many repetitions
  58      of an element in an array.  */
  59   unsigned int repeat_count_threshold;
  60
  61   /* The global output format letter.  */
  62   int output_format;
  63
  64   /* The current format letter.  This is set locally for a given call,
  65      e.g. when the user passes a format to "print".  */
  66   int format;
  67
  68   /* Stop printing at null character?  */
  69   bool stop_print_at_null;
  70
  71   /* True if we should print the index of each element when printing
  72      an array.  */
  73   bool print_array_indexes;
  74
  75   /* If true, then dereference references, otherwise just print
  76      them like pointers.  */
  77   bool deref_ref;
  78
  79   /* If true, print static fields.  */
  80   bool static_field_print;
  81
  82   /* If true, print static fields for Pascal.  FIXME: C++ has a
  83      flag, why not share with Pascal too?  */
  84   bool pascal_static_field_print;
  85
  86   /* If true, don't do Python pretty-printing.  */
  87   bool raw;
  88
  89   /* If true, print the value in "summary" form.
  90      If raw and summary are both true, don't print non-scalar values
  91      ("..." is printed instead).  */
  92   bool summary;
  93
  94   /* If true, when printing a pointer, print the symbol to which it
  95      points, if any.  */
  96   bool symbol_print;
  97
  98   /* Maximum print depth when printing nested aggregates.  */
  99   int max_depth;
 100
 101   /* Whether "finish" should print the value.  */
 102   bool finish_print;
 103 };
 104
 105 /* Create an option_def_group for the value_print options, with OPTS
 106    as context.  */
 107 extern gdb::option::option_def_group make_value_print_options_def_group
 108   (value_print_options *opts);
 109
 110 /* The global print options set by the user.  In general this should
 111    not be directly accessed, except by set/show commands.  Ordinary
 112    code should call get_user_print_options instead.  */
 113 extern struct value_print_options user_print_options;
 114
 115 /* Initialize *OPTS to be a copy of the user print options.  */
 116 extern void get_user_print_options (struct value_print_options *opts);
 117
 118 /* Initialize *OPTS to be a copy of the user print options, but with
 119    pretty-formatting disabled.  */
 120 extern void get_no_prettyformat_print_options (struct value_print_options *);
 121
 122 /* Initialize *OPTS to be a copy of the user print options, but using
 123    FORMAT as the formatting option.  */
 124 extern void get_formatted_print_options (struct value_print_options *opts,
 125                                          char format);
 126
 127 extern void maybe_print_array_index (struct type *index_type, LONGEST index,
 128                                      struct ui_file *stream,
 129                                      const struct value_print_options *);
 130
 131 extern void val_print_array_elements (struct type *, LONGEST,
 132                                       CORE_ADDR, struct ui_file *, int,
 133                                       struct value *,
 134                                       const struct value_print_options *,
 135                                       unsigned int);
 136
 137 /* Print elements of an array.  */
 138
 139 extern void value_print_array_elements (struct value *, struct ui_file *, int,
 140                                         const struct value_print_options *,
 141                                         unsigned int);
 142
 143 extern void val_print_scalar_formatted (struct type *,
 144                                         LONGEST,
 145                                         struct value *,
 146                                         const struct value_print_options *,
 147                                         int,
 148                                         struct ui_file *);
 149
 150 /* Print a scalar according to OPTIONS and SIZE on STREAM.  Format 'i'
 151    is not supported at this level.
 152
 153    This is how the elements of an array or structure are printed
 154    with a format.  */
 155
 156 extern void value_print_scalar_formatted
 157   (struct value *val, const struct value_print_options *options,
 158    int size, struct ui_file *stream);
 159
 160 extern void print_binary_chars (struct ui_file *, const gdb_byte *,
 161                                 unsigned int, enum bfd_endian, bool);
 162
 163 extern void print_octal_chars (struct ui_file *, const gdb_byte *,
 164                                unsigned int, enum bfd_endian);
 165
 166 extern void print_decimal_chars (struct ui_file *, const gdb_byte *,
 167                                  unsigned int, bool, enum bfd_endian);
 168
 169 extern void print_hex_chars (struct ui_file *, const gdb_byte *,
 170                              unsigned int, enum bfd_endian, bool);
 171
 172 extern void print_char_chars (struct ui_file *, struct type *,
 173                               const gdb_byte *, unsigned int, enum bfd_endian);
 174
 175 extern void print_function_pointer_address (const struct value_print_options *options,
 176                                             struct gdbarch *gdbarch,
 177                                             CORE_ADDR address,
 178                                             struct ui_file *stream);
 179
 180 extern int read_string (CORE_ADDR addr, int len, int width,
 181                         unsigned int fetchlimit,
 182                         enum bfd_endian byte_order,
 183                         gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
 184                         int *bytes_read);
 185
 186 extern void val_print_optimized_out (const struct value *val,
 187                                      struct ui_file *stream);
 188
 189 /* Prints "<not saved>" to STREAM.  */
 190 extern void val_print_not_saved (struct ui_file *stream);
 191
 192 extern void val_print_unavailable (struct ui_file *stream);
 193
 194 extern void val_print_invalid_address (struct ui_file *stream);
 195
 196 /* An instance of this is passed to generic_val_print and describes
 197    some language-specific ways to print things.  */
 198
 199 struct generic_val_print_decorations
 200 {
 201   /* Printing complex numbers: what to print before, between the
 202      elements, and after.  */
 203
 204   const char *complex_prefix;
 205   const char *complex_infix;
 206   const char *complex_suffix;
 207
 208   /* Boolean true and false.  */
 209
 210   const char *true_name;
 211   const char *false_name;
 212
 213   /* What to print when we see TYPE_CODE_VOID.  */
 214
 215   const char *void_name;
 216
 217   /* Array start and end strings.  */
 218   const char *array_start;
 219   const char *array_end;
 220 };
 221
 222
 223 extern void generic_val_print (struct type *type,
 224                                int embedded_offset, CORE_ADDR address,
 225                                struct ui_file *stream, int recurse,
 226                                struct value *original_value,
 227                                const struct value_print_options *options,
 228                                const struct generic_val_print_decorations *);
 229
 230 /* Print a value in a generic way.  VAL is the value, STREAM is where
 231    to print it, RECURSE is the recursion depth, OPTIONS describe how
 232    the printing should be done, and D is the language-specific
 233    decorations object.  Note that structs and unions cannot be printed
 234    by this function.  */
 235
 236 extern void generic_value_print (struct value *val, struct ui_file *stream,
 237                                  int recurse,
 238                                  const struct value_print_options *options,
 239                                  const struct generic_val_print_decorations *d);
 240
 241 extern void generic_emit_char (int c, struct type *type, struct ui_file *stream,
 242                                int quoter, const char *encoding);
 243
 244 extern void generic_printstr (struct ui_file *stream, struct type *type,
 245                               const gdb_byte *string, unsigned int length,
 246                               const char *encoding, int force_ellipses,
 247                               int quote_char, int c_style_terminator,
 248                               const struct value_print_options *options);
 249
 250 /* Run the "output" command.  ARGS and FROM_TTY are the usual
 251    arguments passed to all command implementations, except ARGS is
 252    const.  */
 253
 254 extern void output_command (const char *args, int from_tty);
 255
 256 extern int val_print_scalar_type_p (struct type *type);
 257
 258 struct format_data
 259   {
 260     int count;
 261     char format;
 262     char size;
 263
 264     /* True if the value should be printed raw -- that is, bypassing
 265        python-based formatters.  */
 266     unsigned char raw;
 267   };
 268
 269 extern void print_command_parse_format (const char **expp, const char *cmdname,
 270                                         value_print_options *opts);
 271
 272 /* Print VAL to console according to OPTS, including recording it to
 273    the history.  */
 274 extern void print_value (value *val, const value_print_options &opts);
 275
 276 /* Completer for the "print", "call", and "compile print"
 277    commands.  */
 278 extern void print_command_completer (struct cmd_list_element *ignore,
 279                                      completion_tracker &tracker,
 280                                      const char *text, const char *word);
 281
 282 /* Given an address ADDR return all the elements needed to print the
 283    address in a symbolic form.  NAME can be mangled or not depending
 284    on DO_DEMANGLE (and also on the asm_demangle global variable,
 285    manipulated via ''set print asm-demangle'').  When
 286    PREFER_SYM_OVER_MINSYM is true, names (and offsets) from minimal
 287    symbols won't be used except in instances where no symbol was
 288    found; otherwise, a minsym might be used in some instances (mostly
 289    involving function with non-contiguous address ranges).  Return
 290    0 in case of success, when all the info in the OUT parameters is
 291    valid.  Return 1 otherwise.  */
 292
 293 extern int build_address_symbolic (struct gdbarch *,
 294                                    CORE_ADDR addr,
 295                                    bool do_demangle,
 296                                    bool prefer_sym_over_minsym,
 297                                    std::string *name,
 298                                    int *offset,
 299                                    std::string *filename,
 300                                    int *line,
 301                                    int *unmapped);
 302
 303 /* Check to see if RECURSE is greater than or equal to the allowed
 304    printing max-depth (see 'set print max-depth').  If it is then print an
 305    ellipsis expression to STREAM and return true, otherwise return false.
 306    LANGUAGE determines what type of ellipsis expression is printed.  */
 307
 308 extern bool val_print_check_max_depth (struct ui_file *stream, int recurse,
 309                                        const struct value_print_options *opts,
 310                                        const struct language_defn *language);
 311
 312 /* Like common_val_print, but call value_check_printable first.  */
 313
 314 extern void common_val_print_checked
 315   (struct value *val,
 316    struct ui_file *stream, int recurse,
 317    const struct value_print_options *options,
 318    const struct language_defn *language);
 319
 320 #endif