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-2019 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/scoped_restore.h"
  26 #include <chrono>
  27
  28 struct completion_match_for_lcd;
  29 class compiled_regex;
  30
  31 /* String utilities.  */
  32
  33 extern bool sevenbit_strings;
  34
  35 /* Modes of operation for strncmp_iw_with_mode.  */
  36
  37 enum class strncmp_iw_mode
  38 {
  39 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
  40    differences in whitespace.  Returns 0 if they match, non-zero if
  41    they don't (slightly different than strcmp()'s range of return
  42    values).  */
  43   NORMAL,
  44
  45   /* Like NORMAL, but also apply the strcmp_iw hack.  I.e.,
  46      string1=="FOO(PARAMS)" matches string2=="FOO".  */
  47   MATCH_PARAMS,
  48 };
  49
  50 /* Helper for strcmp_iw and strncmp_iw.  Exported so that languages
  51    can implement both NORMAL and MATCH_PARAMS variants in a single
  52    function and defer part of the work to strncmp_iw_with_mode.
  53
  54    LANGUAGE is used to implement some context-sensitive
  55    language-specific comparisons.  For example, for C++,
  56    "string1=operator()" should not match "string2=operator" even in
  57    MATCH_PARAMS mode.
  58
  59    MATCH_FOR_LCD is passed down so that the function can mark parts of
  60    the symbol name as ignored for completion matching purposes (e.g.,
  61    to handle abi tags).  */
  62 extern int strncmp_iw_with_mode
  63   (const char *string1, const char *string2, size_t string2_len,
  64    strncmp_iw_mode mode, enum language language,
  65    completion_match_for_lcd *match_for_lcd = NULL);
  66
  67 /* Do a strncmp() type operation on STRING1 and STRING2, ignoring any
  68    differences in whitespace.  STRING2_LEN is STRING2's length.
  69    Returns 0 if STRING1 matches STRING2_LEN characters of STRING2,
  70    non-zero otherwise (slightly different than strncmp()'s range of
  71    return values).  Note: passes language_minimal to
  72    strncmp_iw_with_mode, and should therefore be avoided if a more
  73    suitable language is available.  */
  74 extern int strncmp_iw (const char *string1, const char *string2,
  75                        size_t string2_len);
  76
  77 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
  78    differences in whitespace.  Returns 0 if they match, non-zero if
  79    they don't (slightly different than strcmp()'s range of return
  80    values).
  81
  82    As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
  83    This "feature" is useful when searching for matching C++ function
  84    names (such as if the user types 'break FOO', where FOO is a
  85    mangled C++ function).
  86
  87    Note: passes language_minimal to strncmp_iw_with_mode, and should
  88    therefore be avoided if a more suitable language is available.  */
  89 extern int strcmp_iw (const char *string1, const char *string2);
  90
  91 extern int strcmp_iw_ordered (const char *, const char *);
  92
  93 /* Return true if the strings are equal.  */
  94
  95 extern bool streq (const char *, const char *);
  96
  97 /* A variant of streq that is suitable for use as an htab
  98    callback.  */
  99
 100 extern int streq_hash (const void *, const void *);
 101
 102 extern int subset_compare (const char *, const char *);
 103
 104 int compare_positive_ints (const void *ap, const void *bp);
 105
 106 /* Compare C strings for std::sort.  */
 107
 108 static inline bool
 109 compare_cstrings (const char *str1, const char *str2)
 110 {
 111   return strcmp (str1, str2) < 0;
 112 }
 113
 114 /* A wrapper for bfd_errmsg to produce a more helpful error message
 115    in the case of bfd_error_file_ambiguously recognized.
 116    MATCHING, if non-NULL, is the corresponding argument to
 117    bfd_check_format_matches, and will be freed.  */
 118
 119 extern std::string gdb_bfd_errmsg (bfd_error_type error_tag, char **matching);
 120
 121 /* Reset the prompt_for_continue clock.  */
 122 void reset_prompt_for_continue_wait_time (void);
 123 /* Return the time spent in prompt_for_continue.  */
 124 std::chrono::steady_clock::duration get_prompt_for_continue_wait_time ();
 125 \f
 126 /* Parsing utilites.  */
 127
 128 extern int parse_pid_to_attach (const char *args);
 129
 130 extern int parse_escape (struct gdbarch *, const char **);
 131
 132 /* A wrapper for an array of char* that was allocated in the way that
 133    'buildargv' does, and should be freed with 'freeargv'.  */
 134
 135 class gdb_argv
 136 {
 137 public:
 138
 139   /* A constructor that initializes to NULL.  */
 140
 141   gdb_argv ()
 142     : m_argv (NULL)
 143   {
 144   }
 145
 146   /* A constructor that calls buildargv on STR.  STR may be NULL, in
 147      which case this object is initialized with a NULL array.  If
 148      buildargv fails due to out-of-memory, call malloc_failure.
 149      Therefore, the value is guaranteed to be non-NULL, unless the
 150      parameter itself is NULL.  */
 151
 152   explicit gdb_argv (const char *str)
 153     : m_argv (NULL)
 154   {
 155     reset (str);
 156   }
 157
 158   /* A constructor that takes ownership of an existing array.  */
 159
 160   explicit gdb_argv (char **array)
 161     : m_argv (array)
 162   {
 163   }
 164
 165   gdb_argv (const gdb_argv &) = delete;
 166   gdb_argv &operator= (const gdb_argv &) = delete;
 167
 168   ~gdb_argv ()
 169   {
 170     freeargv (m_argv);
 171   }
 172
 173   /* Call buildargv on STR, storing the result in this object.  Any
 174      previous state is freed.  STR may be NULL, in which case this
 175      object is reset with a NULL array.  If buildargv fails due to
 176      out-of-memory, call malloc_failure.  Therefore, the value is
 177      guaranteed to be non-NULL, unless the parameter itself is
 178      NULL.  */
 179
 180   void reset (const char *str);
 181
 182   /* Return the underlying array.  */
 183
 184   char **get ()
 185   {
 186     return m_argv;
 187   }
 188
 189   /* Return the underlying array, transferring ownership to the
 190      caller.  */
 191
 192   ATTRIBUTE_UNUSED_RESULT char **release ()
 193   {
 194     char **result = m_argv;
 195     m_argv = NULL;
 196     return result;
 197   }
 198
 199   /* Return the number of items in the array.  */
 200
 201   int count () const
 202   {
 203     return countargv (m_argv);
 204   }
 205
 206   /* Index into the array.  */
 207
 208   char *operator[] (int arg)
 209   {
 210     gdb_assert (m_argv != NULL);
 211     return m_argv[arg];
 212   }
 213
 214   /* The iterator type.  */
 215
 216   typedef char **iterator;
 217
 218   /* Return an iterator pointing to the start of the array.  */
 219
 220   iterator begin ()
 221   {
 222     return m_argv;
 223   }
 224
 225   /* Return an iterator pointing to the end of the array.  */
 226
 227   iterator end ()
 228   {
 229     return m_argv + count ();
 230   }
 231
 232   bool operator!= (std::nullptr_t)
 233   {
 234     return m_argv != NULL;
 235   }
 236
 237   bool operator== (std::nullptr_t)
 238   {
 239     return m_argv == NULL;
 240   }
 241
 242 private:
 243
 244   /* The wrapped array.  */
 245
 246   char **m_argv;
 247 };
 248
 249 \f
 250 /* Cleanup utilities.  */
 251
 252 /* A deleter for a hash table.  */
 253 struct htab_deleter
 254 {
 255   void operator() (htab *ptr) const
 256   {
 257     htab_delete (ptr);
 258   }
 259 };
 260
 261 /* A unique_ptr wrapper for htab_t.  */
 262 typedef std::unique_ptr<htab, htab_deleter> htab_up;
 263
 264 extern void init_page_info (void);
 265
 266 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
 267    Restore when destroyed.  */
 268
 269 struct set_batch_flag_and_restore_page_info
 270 {
 271 public:
 272
 273   set_batch_flag_and_restore_page_info ();
 274   ~set_batch_flag_and_restore_page_info ();
 275
 276   DISABLE_COPY_AND_ASSIGN (set_batch_flag_and_restore_page_info);
 277
 278 private:
 279
 280   /* Note that this doesn't use scoped_restore, because it's important
 281      to control the ordering of operations in the destruction, and it
 282      was simpler to avoid introducing a new ad hoc class.  */
 283   unsigned m_save_lines_per_page;
 284   unsigned m_save_chars_per_line;
 285   int m_save_batch_flag;
 286 };
 287
 288 \f
 289 /* Path utilities.  */
 290
 291 extern int gdb_filename_fnmatch (const char *pattern, const char *string,
 292                                  int flags);
 293
 294 extern void substitute_path_component (char **stringp, const char *from,
 295                                        const char *to);
 296
 297 std::string ldirname (const char *filename);
 298
 299 extern int count_path_elements (const char *path);
 300
 301 extern const char *strip_leading_path_elements (const char *path, int n);
 302 \f
 303 /* GDB output, ui_file utilities.  */
 304
 305 struct ui_file;
 306
 307 extern int query (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 308 extern int nquery (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 309 extern int yquery (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 310
 311 extern void begin_line (void);
 312
 313 extern void wrap_here (const char *);
 314
 315 extern void reinitialize_more_filter (void);
 316
 317 extern bool pagination_enabled;
 318
 319 extern struct ui_file **current_ui_gdb_stdout_ptr (void);
 320 extern struct ui_file **current_ui_gdb_stdin_ptr (void);
 321 extern struct ui_file **current_ui_gdb_stderr_ptr (void);
 322 extern struct ui_file **current_ui_gdb_stdlog_ptr (void);
 323
 324 /* The current top level's ui_file streams.  */
 325
 326 /* Normal results */
 327 #define gdb_stdout (*current_ui_gdb_stdout_ptr ())
 328 /* Input stream */
 329 #define gdb_stdin (*current_ui_gdb_stdin_ptr ())
 330 /* Serious error notifications */
 331 #define gdb_stderr (*current_ui_gdb_stderr_ptr ())
 332 /* Log/debug/trace messages that should bypass normal stdout/stderr
 333    filtering.  For moment, always call this stream using
 334    *_unfiltered.  In the very near future that restriction shall be
 335    removed - either call shall be unfiltered.  (cagney 1999-06-13).  */
 336 #define gdb_stdlog (*current_ui_gdb_stdlog_ptr ())
 337
 338 /* Truly global ui_file streams.  These are all defined in main.c.  */
 339
 340 /* Target output that should bypass normal stdout/stderr filtering.
 341    For moment, always call this stream using *_unfiltered.  In the
 342    very near future that restriction shall be removed - either call
 343    shall be unfiltered.  (cagney 1999-07-02).  */
 344 extern struct ui_file *gdb_stdtarg;
 345 extern struct ui_file *gdb_stdtargerr;
 346 extern struct ui_file *gdb_stdtargin;
 347
 348 /* Set the screen dimensions to WIDTH and HEIGHT.  */
 349
 350 extern void set_screen_width_and_height (int width, int height);
 351
 352 /* More generic printf like operations.  Filtered versions may return
 353    non-locally on error.  As an extension over plain printf, these
 354    support some GDB-specific format specifiers.  Particularly useful
 355    here are the styling formatters: '%p[', '%p]' and '%ps'.  See
 356    ui_out::message for details.  */
 357
 358 extern void fputs_filtered (const char *, struct ui_file *);
 359
 360 extern void fputs_unfiltered (const char *, struct ui_file *);
 361
 362 extern int fputc_filtered (int c, struct ui_file *);
 363
 364 extern int fputc_unfiltered (int c, struct ui_file *);
 365
 366 extern int putchar_filtered (int c);
 367
 368 extern int putchar_unfiltered (int c);
 369
 370 extern void puts_filtered (const char *);
 371
 372 extern void puts_unfiltered (const char *);
 373
 374 extern void puts_filtered_tabular (char *string, int width, int right);
 375
 376 extern void puts_debug (char *prefix, char *string, char *suffix);
 377
 378 extern void vprintf_filtered (const char *, va_list) ATTRIBUTE_PRINTF (1, 0);
 379
 380 extern void vfprintf_filtered (struct ui_file *, const char *, va_list)
 381   ATTRIBUTE_PRINTF (2, 0);
 382
 383 extern void fprintf_filtered (struct ui_file *, const char *, ...)
 384   ATTRIBUTE_PRINTF (2, 3);
 385
 386 extern void fprintfi_filtered (int, struct ui_file *, const char *, ...)
 387   ATTRIBUTE_PRINTF (3, 4);
 388
 389 extern void printf_filtered (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 390
 391 extern void printfi_filtered (int, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 392
 393 extern void vprintf_unfiltered (const char *, va_list) ATTRIBUTE_PRINTF (1, 0);
 394
 395 extern void vfprintf_unfiltered (struct ui_file *, const char *, va_list)
 396   ATTRIBUTE_PRINTF (2, 0);
 397
 398 extern void fprintf_unfiltered (struct ui_file *, const char *, ...)
 399   ATTRIBUTE_PRINTF (2, 3);
 400
 401 extern void printf_unfiltered (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
 402
 403 extern void print_spaces (int, struct ui_file *);
 404
 405 extern void print_spaces_filtered (int, struct ui_file *);
 406
 407 extern char *n_spaces (int);
 408
 409 extern void fputstr_filtered (const char *str, int quotr,
 410                               struct ui_file * stream);
 411
 412 extern void fputstr_unfiltered (const char *str, int quotr,
 413                                 struct ui_file * stream);
 414
 415 extern void fputstrn_filtered (const char *str, int n, int quotr,
 416                                struct ui_file * stream);
 417
 418 typedef int (*do_fputc_ftype) (int c, ui_file *stream);
 419
 420 extern void fputstrn_unfiltered (const char *str, int n, int quotr,
 421                                  do_fputc_ftype do_fputc,
 422                                  struct ui_file * stream);
 423
 424 /* Return nonzero if filtered printing is initialized.  */
 425 extern int filtered_printing_initialized (void);
 426
 427 /* Like fprintf_filtered, but styles the output according to STYLE,
 428    when appropriate.  */
 429
 430 extern void fprintf_styled (struct ui_file *stream,
 431                             const ui_file_style &style,
 432                             const char *fmt,
 433                             ...)
 434   ATTRIBUTE_PRINTF (3, 4);
 435
 436 extern void vfprintf_styled (struct ui_file *stream,
 437                              const ui_file_style &style,
 438                              const char *fmt,
 439                              va_list args)
 440   ATTRIBUTE_PRINTF (3, 0);
 441
 442 /* Like vfprintf_styled, but do not process gdb-specific format
 443    specifiers.  */
 444 extern void vfprintf_styled_no_gdbfmt (struct ui_file *stream,
 445                                        const ui_file_style &style,
 446                                        bool filter,
 447                                        const char *fmt, va_list args)
 448   ATTRIBUTE_PRINTF (4, 0);
 449
 450 /* Like fputs_filtered, but styles the output according to STYLE, when
 451    appropriate.  */
 452
 453 extern void fputs_styled (const char *linebuffer,
 454                           const ui_file_style &style,
 455                           struct ui_file *stream);
 456
 457 /* Unfiltered variant of fputs_styled.  */
 458
 459 extern void fputs_styled_unfiltered (const char *linebuffer,
 460                                      const ui_file_style &style,
 461                                      struct ui_file *stream);
 462
 463 /* Like fputs_styled, but uses highlight_style to highlight the
 464    parts of STR that match HIGHLIGHT.  */
 465
 466 extern void fputs_highlighted (const char *str, const compiled_regex &highlight,
 467                                struct ui_file *stream);
 468
 469 /* Reset the terminal style to the default, if needed.  */
 470
 471 extern void reset_terminal_style (struct ui_file *stream);
 472
 473 /* Display the host ADDR on STREAM formatted as ``0x%x''.  */
 474 extern void gdb_print_host_address_1 (const void *addr, struct ui_file *stream);
 475
 476 /* Wrapper that avoids adding a pointless cast to all callers.  */
 477 #define gdb_print_host_address(ADDR, STREAM) \
 478   gdb_print_host_address_1 ((const void *) ADDR, STREAM)
 479
 480 /* Return the address only having significant bits.  */
 481 extern CORE_ADDR address_significant (gdbarch *gdbarch, CORE_ADDR addr);
 482
 483 /* Convert CORE_ADDR to string in platform-specific manner.
 484    This is usually formatted similar to 0x%lx.  */
 485 extern const char *paddress (struct gdbarch *gdbarch, CORE_ADDR addr);
 486
 487 /* Return a string representation in hexadecimal notation of ADDRESS,
 488    which is suitable for printing.  */
 489
 490 extern const char *print_core_address (struct gdbarch *gdbarch,
 491                                        CORE_ADDR address);
 492
 493 /* Callback hash_f and eq_f for htab_create_alloc or htab_create_alloc_ex.  */
 494 extern hashval_t core_addr_hash (const void *ap);
 495 extern int core_addr_eq (const void *ap, const void *bp);
 496
 497 extern CORE_ADDR string_to_core_addr (const char *my_string);
 498
 499 extern void fprintf_symbol_filtered (struct ui_file *, const char *,
 500                                      enum language, int);
 501
 502 extern void throw_perror_with_name (enum errors errcode, const char *string)
 503   ATTRIBUTE_NORETURN;
 504
 505 extern void perror_warning_with_name (const char *string);
 506
 507 extern void print_sys_errmsg (const char *, int);
 508 \f
 509 /* Warnings and error messages.  */
 510
 511 extern void (*deprecated_error_begin_hook) (void);
 512
 513 /* Message to be printed before the warning message, when a warning occurs.  */
 514
 515 extern const char *warning_pre_print;
 516
 517 extern void error_stream (const string_file &) ATTRIBUTE_NORETURN;
 518
 519 extern void demangler_vwarning (const char *file, int line,
 520                                const char *, va_list ap)
 521      ATTRIBUTE_PRINTF (3, 0);
 522
 523 extern void demangler_warning (const char *file, int line,
 524                               const char *, ...) ATTRIBUTE_PRINTF (3, 4);
 525
 526 \f
 527 /* Misc. utilities.  */
 528
 529 /* Allocation and deallocation functions for the libiberty hash table
 530    which use obstacks.  */
 531 void *hashtab_obstack_allocate (void *data, size_t size, size_t count);
 532 void dummy_obstack_deallocate (void *object, void *data);
 533
 534 #ifdef HAVE_WAITPID
 535 extern pid_t wait_to_die_with_timeout (pid_t pid, int *status, int timeout);
 536 #endif
 537
 538 extern int myread (int, char *, int);
 539
 540 /* Resource limits used by getrlimit and setrlimit.  */
 541
 542 enum resource_limit_kind
 543   {
 544     LIMIT_CUR,
 545     LIMIT_MAX
 546   };
 547
 548 /* Check whether GDB will be able to dump core using the dump_core
 549    function.  Returns zero if GDB cannot or should not dump core.
 550    If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
 551    If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected.  */
 552
 553 extern int can_dump_core (enum resource_limit_kind limit_kind);
 554
 555 /* Print a warning that we cannot dump core.  */
 556
 557 extern void warn_cant_dump_core (const char *reason);
 558
 559 /* Dump core trying to increase the core soft limit to hard limit
 560    first.  */
 561
 562 extern void dump_core (void);
 563
 564 /* Copy NBITS bits from SOURCE to DEST starting at the given bit
 565    offsets.  Use the bit order as specified by BITS_BIG_ENDIAN.
 566    Source and destination buffers must not overlap.  */
 567
 568 extern void copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
 569                           const gdb_byte *source, ULONGEST source_offset,
 570                           ULONGEST nbits, int bits_big_endian);
 571
 572 #endif /* UTILS_H */