gdb/valprint.h

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