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