gdb/utils.h

   1 /* *INDENT-OFF* */ /* ATTRIBUTE_PRINTF confuses indent, avoid running it
   2                       for now.  */
   3 /* I/O, string, cleanup, and other random utilities for GDB.
   4    Copyright (C) 1986-2022 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef UTILS_H
  22 #define UTILS_H
  23
  24 #include "exceptions.h"
  25 #include "gdbsupport/array-view.h"
  26 #include "gdbsupport/scoped_restore.h"
  27 #include <chrono>
  28
  29 #ifdef HAVE_LIBXXHASH
  30 #include <xxhash.h>
  31 #endif
  32
  33 struct completion_match_for_lcd;
  34 class compiled_regex;
  35
  36 /* String utilities.  */
  37
  38 extern bool sevenbit_strings;
  39
  40 /* Modes of operation for strncmp_iw_with_mode.  */
  41
  42 enum class strncmp_iw_mode
  43 {
  44 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
  45    differences in whitespace.  Returns 0 if they match, non-zero if
  46    they don't (slightly different than strcmp()'s range of return
  47    values).  */
  48   NORMAL,
  49
  50   /* Like NORMAL, but also apply the strcmp_iw hack.  I.e.,
  51      string1=="FOO(PARAMS)" matches string2=="FOO".  */
  52   MATCH_PARAMS,
  53 };
  54
  55 /* Helper for strcmp_iw and strncmp_iw.  Exported so that languages
  56    can implement both NORMAL and MATCH_PARAMS variants in a single
  57    function and defer part of the work to strncmp_iw_with_mode.
  58
  59    LANGUAGE is used to implement some context-sensitive
  60    language-specific comparisons.  For example, for C++,
  61    "string1=operator()" should not match "string2=operator" even in
  62    MATCH_PARAMS mode.
  63
  64    MATCH_FOR_LCD is passed down so that the function can mark parts of
  65    the symbol name as ignored for completion matching purposes (e.g.,
  66    to handle abi tags).  If IGNORE_TEMPLATE_PARAMS is true, all template
  67    parameter lists will be ignored when language is C++.  */
  68
  69 extern int strncmp_iw_with_mode
  70   (const char *string1, const char *string2, size_t string2_len,
  71    strncmp_iw_mode mode, enum language language,
  72    completion_match_for_lcd *match_for_lcd = NULL,
  73    bool ignore_template_params = false);
  74
  75 /* Do a strncmp() type operation on STRING1 and STRING2, ignoring any
  76    differences in whitespace.  STRING2_LEN is STRING2's length.
  77    Returns 0 if STRING1 matches STRING2_LEN characters of STRING2,
  78    non-zero otherwise (slightly different than strncmp()'s range of
  79    return values).  Note: passes language_minimal to
  80    strncmp_iw_with_mode, and should therefore be avoided if a more
  81    suitable language is available.  */
  82 extern int strncmp_iw (const char *string1, const char *string2,
  83                        size_t string2_len);
  84
  85 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
  86    differences in whitespace.  Returns 0 if they match, non-zero if
  87    they don't (slightly different than strcmp()'s range of return
  88    values).
  89
  90    As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
  91    This "feature" is useful when searching for matching C++ function
  92    names (such as if the user types 'break FOO', where FOO is a
  93    mangled C++ function).
  94
  95    Note: passes language_minimal to strncmp_iw_with_mode, and should
  96    therefore be avoided if a more suitable language is available.  */
  97 extern int strcmp_iw (const char *string1, const char *string2);
  98
  99 extern int strcmp_iw_ordered (const char *, const char *);
 100
 101 /* Return true if the strings are equal.  */
 102
 103 extern bool streq (const char *, const char *);
 104
 105 extern int subset_compare (const char *, const char *);
 106
 107 /* Compare C strings for std::sort.  */
 108
 109 static inline bool
 110 compare_cstrings (const char *str1, const char *str2)
 111 {
 112   return strcmp (str1, str2) < 0;
 113 }
 114
 115 /* Reset the prompt_for_continue clock.  */
 116 void reset_prompt_for_continue_wait_time (void);
 117 /* Return the time spent in prompt_for_continue.  */
 118 std::chrono::steady_clock::duration get_prompt_for_continue_wait_time ();
 119 \f
 120 /* Parsing utilities.  */
 121
 122 extern int parse_pid_to_attach (const char *args);
 123
 124 extern int parse_escape (struct gdbarch *, const char **);
 125
 126 \f
 127 /* Cleanup utilities.  */
 128
 129 extern void init_page_info (void);
 130
 131 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
 132    Restore when destroyed.  */
 133
 134 struct set_batch_flag_and_restore_page_info
 135 {
 136 public:
 137
 138   set_batch_flag_and_restore_page_info ();
 139   ~set_batch_flag_and_restore_page_info ();
 140
 141   DISABLE_COPY_AND_ASSIGN (set_batch_flag_and_restore_page_info);
 142
 143 private:
 144
 145   /* Note that this doesn't use scoped_restore, because it's important
 146      to control the ordering of operations in the destruction, and it
 147      was simpler to avoid introducing a new ad hoc class.  */
 148   unsigned m_save_lines_per_page;
 149   unsigned m_save_chars_per_line;
 150   int m_save_batch_flag;
 151 };
 152
 153 \f
 154 /* Path utilities.  */
 155
 156 extern int gdb_filename_fnmatch (const char *pattern, const char *string,
 157                                  int flags);
 158
 159 extern void substitute_path_component (char **stringp, const char *from,
 160                                        const char *to);
 161
 162 std::string ldirname (const char *filename);
 163
 164 extern int count_path_elements (const char *path);
 165
 166 extern const char *strip_leading_path_elements (const char *path, int n);
 167 \f
 168 /* GDB output, ui_file utilities.  */
 169
 170 struct ui_file;
 171
 172 extern int query (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 173 extern int nquery (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 174 extern int yquery (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 175
 176 extern void begin_line (void);
 177
 178 extern void wrap_here (int);
 179
 180 extern void reinitialize_more_filter (void);
 181
 182 /* Return the number of characters in a line.  */
 183
 184 extern int get_chars_per_line ();
 185
 186 extern bool pagination_enabled;
 187
 188 /* A flag indicating whether to timestamp debugging messages.  */
 189 extern bool debug_timestamp;
 190
 191 extern struct ui_file **current_ui_gdb_stdout_ptr (void);
 192 extern struct ui_file **current_ui_gdb_stdin_ptr (void);
 193 extern struct ui_file **current_ui_gdb_stderr_ptr (void);
 194 extern struct ui_file **current_ui_gdb_stdlog_ptr (void);
 195
 196 /* Flush STREAM.  This is a wrapper for ui_file_flush that also
 197    flushes any output pending from uses of the *_filtered output
 198    functions; that output is kept in a special buffer so that
 199    pagination and styling are handled properly.  */
 200 extern void gdb_flush (struct ui_file *);
 201
 202 /* The current top level's ui_file streams.  */
 203
 204 /* Normal results */
 205 #define gdb_stdout (*current_ui_gdb_stdout_ptr ())
 206 /* Input stream */
 207 #define gdb_stdin (*current_ui_gdb_stdin_ptr ())
 208 /* Serious error notifications */
 209 #define gdb_stderr (*current_ui_gdb_stderr_ptr ())
 210 /* Log/debug/trace messages that should bypass normal stdout/stderr
 211    filtering.  For moment, always call this stream using
 212    *_unfiltered.  In the very near future that restriction shall be
 213    removed - either call shall be unfiltered.  (cagney 1999-06-13).  */
 214 #define gdb_stdlog (*current_ui_gdb_stdlog_ptr ())
 215
 216 /* Truly global ui_file streams.  These are all defined in main.c.  */
 217
 218 /* Target output that should bypass normal stdout/stderr filtering.
 219    For moment, always call this stream using *_unfiltered.  In the
 220    very near future that restriction shall be removed - either call
 221    shall be unfiltered.  (cagney 1999-07-02).  */
 222 extern struct ui_file *gdb_stdtarg;
 223 extern struct ui_file *gdb_stdtargerr;
 224 extern struct ui_file *gdb_stdtargin;
 225
 226 /* Set the screen dimensions to WIDTH and HEIGHT.  */
 227
 228 extern void set_screen_width_and_height (int width, int height);
 229
 230 /* More generic printf like operations.  Filtered versions may return
 231    non-locally on error.  As an extension over plain printf, these
 232    support some GDB-specific format specifiers.  Particularly useful
 233    here are the styling formatters: '%p[', '%p]' and '%ps'.  See
 234    ui_out::message for details.  */
 235
 236 extern void gdb_puts (const char *, struct ui_file *);
 237
 238 extern int gdb_putc (int c, struct ui_file *);
 239
 240 extern int gdb_putc (int c);
 241
 242 extern void gdb_puts (const char *);
 243
 244 extern void puts_filtered_tabular (char *string, int width, int right);
 245
 246 extern void gdb_vprintf (const char *, va_list) ATTRIBUTE_PRINTF (1, 0);
 247
 248 extern void gdb_vprintf (struct ui_file *, const char *, va_list)
 249   ATTRIBUTE_PRINTF (2, 0);
 250
 251 extern void gdb_printf (struct ui_file *, const char *, ...)
 252   ATTRIBUTE_PRINTF (2, 3);
 253
 254 extern void gdb_printf (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 255
 256 extern void printf_unfiltered (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 257
 258 extern void print_spaces_filtered (int, struct ui_file *);
 259
 260 extern const char *n_spaces (int);
 261
 262 /* Return nonzero if filtered printing is initialized.  */
 263 extern int filtered_printing_initialized (void);
 264
 265 /* Like gdb_printf, but styles the output according to STYLE,
 266    when appropriate.  */
 267
 268 extern void fprintf_styled (struct ui_file *stream,
 269                             const ui_file_style &style,
 270                             const char *fmt,
 271                             ...)
 272   ATTRIBUTE_PRINTF (3, 4);
 273
 274 extern void vfprintf_styled (struct ui_file *stream,
 275                              const ui_file_style &style,
 276                              const char *fmt,
 277                              va_list args)
 278   ATTRIBUTE_PRINTF (3, 0);
 279
 280 /* Like gdb_puts, but styles the output according to STYLE, when
 281    appropriate.  */
 282
 283 extern void fputs_styled (const char *linebuffer,
 284                           const ui_file_style &style,
 285                           struct ui_file *stream);
 286
 287 /* Like fputs_styled, but uses highlight_style to highlight the
 288    parts of STR that match HIGHLIGHT.  */
 289
 290 extern void fputs_highlighted (const char *str, const compiled_regex &highlight,
 291                                struct ui_file *stream);
 292
 293 /* Return the address only having significant bits.  */
 294 extern CORE_ADDR address_significant (gdbarch *gdbarch, CORE_ADDR addr);
 295
 296 /* Convert CORE_ADDR to string in platform-specific manner.
 297    This is usually formatted similar to 0x%lx.  */
 298 extern const char *paddress (struct gdbarch *gdbarch, CORE_ADDR addr);
 299
 300 /* Return a string representation in hexadecimal notation of ADDRESS,
 301    which is suitable for printing.  */
 302
 303 extern const char *print_core_address (struct gdbarch *gdbarch,
 304                                        CORE_ADDR address);
 305
 306 extern CORE_ADDR string_to_core_addr (const char *my_string);
 307
 308 extern void fprintf_symbol_filtered (struct ui_file *, const char *,
 309                                      enum language, int);
 310
 311 extern void throw_perror_with_name (enum errors errcode, const char *string)
 312   ATTRIBUTE_NORETURN;
 313
 314 extern void perror_warning_with_name (const char *string);
 315
 316 extern void print_sys_errmsg (const char *, int);
 317 \f
 318 /* Warnings and error messages.  */
 319
 320 extern void (*deprecated_error_begin_hook) (void);
 321
 322 /* Message to be printed before the warning message, when a warning occurs.  */
 323
 324 extern const char *warning_pre_print;
 325
 326 extern void error_stream (const string_file &) ATTRIBUTE_NORETURN;
 327
 328 extern void demangler_vwarning (const char *file, int line,
 329                                const char *, va_list ap)
 330      ATTRIBUTE_PRINTF (3, 0);
 331
 332 extern void demangler_warning (const char *file, int line,
 333                               const char *, ...) ATTRIBUTE_PRINTF (3, 4);
 334
 335 \f
 336 /* Misc. utilities.  */
 337
 338 #ifdef HAVE_WAITPID
 339 extern pid_t wait_to_die_with_timeout (pid_t pid, int *status, int timeout);
 340 #endif
 341
 342 extern int myread (int, char *, int);
 343
 344 /* Integer exponentiation: Return V1**V2, where both arguments
 345    are integers.
 346
 347    Requires V1 != 0 if V2 < 0.
 348    Returns 1 for 0 ** 0.  */
 349 extern ULONGEST uinteger_pow (ULONGEST v1, LONGEST v2);
 350
 351 /* Resource limits used by getrlimit and setrlimit.  */
 352
 353 enum resource_limit_kind
 354   {
 355     LIMIT_CUR,
 356     LIMIT_MAX
 357   };
 358
 359 /* Check whether GDB will be able to dump core using the dump_core
 360    function.  Returns zero if GDB cannot or should not dump core.
 361    If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
 362    If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected.  */
 363
 364 extern int can_dump_core (enum resource_limit_kind limit_kind);
 365
 366 /* Print a warning that we cannot dump core.  */
 367
 368 extern void warn_cant_dump_core (const char *reason);
 369
 370 /* Dump core trying to increase the core soft limit to hard limit
 371    first.  */
 372
 373 extern void dump_core (void);
 374
 375 /* Copy NBITS bits from SOURCE to DEST starting at the given bit
 376    offsets.  Use the bit order as specified by BITS_BIG_ENDIAN.
 377    Source and destination buffers must not overlap.  */
 378
 379 extern void copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
 380                           const gdb_byte *source, ULONGEST source_offset,
 381                           ULONGEST nbits, int bits_big_endian);
 382
 383 /* A fast hashing function.  This can be used to hash data in a fast way
 384    when the length is known.  If no fast hashing library is available, falls
 385    back to iterative_hash from libiberty.  START_VALUE can be set to
 386    continue hashing from a previous value.  */
 387
 388 static inline unsigned int
 389 fast_hash (const void *ptr, size_t len, unsigned int start_value = 0)
 390 {
 391 #ifdef HAVE_LIBXXHASH
 392   return XXH64 (ptr, len, start_value);
 393 #else
 394   return iterative_hash (ptr, len, start_value);
 395 #endif
 396 }
 397
 398 #endif /* UTILS_H */