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