GDB (xrefs)

/tmp/gdb-8.1/gdb/skip.c
Go to the documentation of this file.
1 /* Skipping uninteresting files and functions while stepping.
2
3 Copyright (C) 2011-2018 Free Software Foundation, Inc.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17
18 #include "defs.h"
19 #include "skip.h"
20 #include "value.h"
21 #include "valprint.h"
22 #include "ui-out.h"
23 #include "symtab.h"
24 #include "gdbcmd.h"
25 #include "command.h"
26 #include "completer.h"
27 #include "stack.h"
28 #include "cli/cli-utils.h"
29 #include "arch-utils.h"
30 #include "linespec.h"
31 #include "objfiles.h"
32 #include "breakpoint.h" /* for get_sal_arch () */
33 #include "source.h"
34 #include "filenames.h"
35 #include "fnmatch.h"
36 #include "gdb_regex.h"
37 #include "common/gdb_optional.h"
38 #include <list>
39
40 class skiplist_entry
41 {
42 public:
43 /* Create a skiplist_entry object and add it to the chain. */
44 static void add_entry (bool file_is_glob,
45 std::string &&file,
46 bool function_is_regexp,
47 std::string &&function);
48
49 /* Return true if the skip entry has a file or glob-style file
50 pattern that matches FUNCTION_SAL. */
51 bool skip_file_p (const symtab_and_line &function_sal) const;
52
53 /* Return true if the skip entry has a function or function regexp
54 that matches FUNCTION_NAME. */
55 bool skip_function_p (const char *function_name) const;
56
57 /* Getters. */
58 int number () const { return m_number; };
59 bool enabled () const { return m_enabled; };
60 bool file_is_glob () const { return m_file_is_glob; }
61 const std::string &file () const { return m_file; }
62 const std::string &function () const { return m_function; }
63 bool function_is_regexp () const { return m_function_is_regexp; }
64
65 /* Setters. */
66 void enable () { m_enabled = true; };
67 void disable () { m_enabled = false; };
68
69 /* Disable copy. */
70 skiplist_entry (const skiplist_entry &) = delete;
71 void operator= (const skiplist_entry &) = delete;
72
73 private:
74 /* Key that grants access to the constructor. */
75 struct private_key {};
76 public:
77 /* Public so we can construct with container::emplace_back. Since
78 it requires a private class key, it can't be called from outside.
79 Use the add_entry static factory method to construct instead. */
80 skiplist_entry (bool file_is_glob, std::string &&file,
81 bool function_is_regexp, std::string &&function,
82 private_key);
83
84 private:
85 /* Return true if we're stopped at a file to be skipped. */
86 bool do_skip_file_p (const symtab_and_line &function_sal) const;
87
88 /* Return true if we're stopped at a globbed file to be skipped. */
89 bool do_skip_gfile_p (const symtab_and_line &function_sal) const;
90
91 private: /* data */
92 int m_number = -1;
93
94 /* True if FILE is a glob-style pattern.
95 Otherwise it is the plain file name (possibly with directories). */
96 bool m_file_is_glob;
97
98 /* The name of the file or empty if no name. */
99 std::string m_file;
100
101 /* True if FUNCTION is a regexp.
102 Otherwise it is a plain function name (possibly with arguments,
103 for C++). */
104 bool m_function_is_regexp;
105
106 /* The name of the function or empty if no name. */
107 std::string m_function;
108
109 /* If this is a function regexp, the compiled form. */
110 gdb::optional<compiled_regex> m_compiled_function_regexp;
111
112 /* Enabled/disabled state. */
113 bool m_enabled = true;
114 };
115
116 static std::list<skiplist_entry> skiplist_entries;
117 static int highest_skiplist_entry_num = 0;
118
119 skiplist_entry::skiplist_entry (bool file_is_glob,
120 std::string &&file,
121 bool function_is_regexp,
122 std::string &&function,
123 private_key)
124 : m_file_is_glob (file_is_glob),
125 m_file (std::move (file)),
126 m_function_is_regexp (function_is_regexp),
127 m_function (std::move (function))
128 {
129 gdb_assert (!m_file.empty () || !m_function.empty ());
130
131 if (m_file_is_glob)
132 gdb_assert (!m_file.empty ());
133
134 if (m_function_is_regexp)
135 {
136 gdb_assert (!m_function.empty ());
137
138 int flags = REG_NOSUB;
139 #ifdef REG_EXTENDED
140 flags |= REG_EXTENDED;
141 #endif
142
143 gdb_assert (!m_function.empty ());
144 m_compiled_function_regexp.emplace (m_function.c_str (), flags,
145 _("regexp"));
146 }
147 }
148
149 void
150 skiplist_entry::add_entry (bool file_is_glob, std::string &&file,
151 bool function_is_regexp, std::string &&function)
152 {
153 skiplist_entries.emplace_back (file_is_glob,
154 std::move (file),
155 function_is_regexp,
156 std::move (function),
157 private_key {});
158
159 /* Incremented after push_back, in case push_back throws. */
160 skiplist_entries.back ().m_number = ++highest_skiplist_entry_num;
161 }
162
163 static void
164 skip_file_command (const char *arg, int from_tty)
165 {
166 struct symtab *symtab;
167 const char *filename = NULL;
168
169 /* If no argument was given, try to default to the last
170 displayed codepoint. */
171 if (arg == NULL)
172 {
173 symtab = get_last_displayed_symtab ();
174 if (symtab == NULL)
175 error (_("No default file now."));
176
177 /* It is not a typo, symtab_to_filename_for_display woule be needlessly
178 ambiguous. */
179 filename = symtab_to_fullname (symtab);
180 }
181 else
182 filename = arg;
183
184 skiplist_entry::add_entry (false, std::string (filename),
185 false, std::string ());
186
187 printf_filtered (_("File %s will be skipped when stepping.\n"), filename);
188 }
189
190 /* Create a skiplist entry for the given function NAME and add it to the
191 list. */
192
193 static void
194 skip_function (const char *name)
195 {
196 skiplist_entry::add_entry (false, std::string (), false, std::string (name));
197
198 printf_filtered (_("Function %s will be skipped when stepping.\n"), name);
199 }
200
201 static void
202 skip_function_command (const char *arg, int from_tty)
203 {
204 /* Default to the current function if no argument is given. */
205 if (arg == NULL)
206 {
207 const char *name = NULL;
208 CORE_ADDR pc;
209
210 if (!last_displayed_sal_is_valid ())
211 error (_("No default function now."));
212
213 pc = get_last_displayed_addr ();
214 if (!find_pc_partial_function (pc, &name, NULL, NULL))
215 {
216 error (_("No function found containing current program point %s."),
217 paddress (get_current_arch (), pc));
218 }
219 skip_function (name);
220 return;
221 }
222
223 skip_function (arg);
224 }
225
226 /* Process "skip ..." that does not match "skip file" or "skip function". */
227
228 static void
229 skip_command (const char *arg, int from_tty)
230 {
231 const char *file = NULL;
232 const char *gfile = NULL;
233 const char *function = NULL;
234 const char *rfunction = NULL;
235 int i;
236
237 if (arg == NULL)
238 {
239 skip_function_command (arg, from_tty);
240 return;
241 }
242
243 gdb_argv argv (arg);
244
245 for (i = 0; argv[i] != NULL; ++i)
246 {
247 const char *p = argv[i];
248 const char *value = argv[i + 1];
249
250 if (strcmp (p, "-fi") == 0
251 || strcmp (p, "-file") == 0)
252 {
253 if (value == NULL)
254 error (_("Missing value for %s option."), p);
255 file = value;
256 ++i;
257 }
258 else if (strcmp (p, "-gfi") == 0
259 || strcmp (p, "-gfile") == 0)
260 {
261 if (value == NULL)
262 error (_("Missing value for %s option."), p);
263 gfile = value;
264 ++i;
265 }
266 else if (strcmp (p, "-fu") == 0
267 || strcmp (p, "-function") == 0)
268 {
269 if (value == NULL)
270 error (_("Missing value for %s option."), p);
271 function = value;
272 ++i;
273 }
274 else if (strcmp (p, "-rfu") == 0
275 || strcmp (p, "-rfunction") == 0)
276 {
277 if (value == NULL)
278 error (_("Missing value for %s option."), p);
279 rfunction = value;
280 ++i;
281 }
282 else if (*p == '-')
283 error (_("Invalid skip option: %s"), p);
284 else if (i == 0)
285 {
286 /* Assume the user entered "skip FUNCTION-NAME".
287 FUNCTION-NAME may be `foo (int)', and therefore we pass the
288 complete original arg to skip_function command as if the user
289 typed "skip function arg". */
290 skip_function_command (arg, from_tty);
291 return;
292 }
293 else
294 error (_("Invalid argument: %s"), p);
295 }
296
297 if (file != NULL && gfile != NULL)
298 error (_("Cannot specify both -file and -gfile."));
299
300 if (function != NULL && rfunction != NULL)
301 error (_("Cannot specify both -function and -rfunction."));
302
303 /* This shouldn't happen as "skip" by itself gets punted to
304 skip_function_command. */
305 gdb_assert (file != NULL || gfile != NULL
306 || function != NULL || rfunction != NULL);
307
308 std::string entry_file;
309 if (file != NULL)
310 entry_file = file;
311 else if (gfile != NULL)
312 entry_file = gfile;
313
314 std::string entry_function;
315 if (function != NULL)
316 entry_function = function;
317 else if (rfunction != NULL)
318 entry_function = rfunction;
319
320 skiplist_entry::add_entry (gfile != NULL, std::move (entry_file),
321 rfunction != NULL, std::move (entry_function));
322
323 /* I18N concerns drive some of the choices here (we can't piece together
324 the output too much). OTOH we want to keep this simple. Therefore the
325 only polish we add to the output is to append "(s)" to "File" or
326 "Function" if they're a glob/regexp. */
327 {
328 const char *file_to_print = file != NULL ? file : gfile;
329 const char *function_to_print = function != NULL ? function : rfunction;
330 const char *file_text = gfile != NULL ? _("File(s)") : _("File");
331 const char *lower_file_text = gfile != NULL ? _("file(s)") : _("file");
332 const char *function_text
333 = rfunction != NULL ? _("Function(s)") : _("Function");
334
335 if (function_to_print == NULL)
336 {
337 printf_filtered (_("%s %s will be skipped when stepping.\n"),
338 file_text, file_to_print);
339 }
340 else if (file_to_print == NULL)
341 {
342 printf_filtered (_("%s %s will be skipped when stepping.\n"),
343 function_text, function_to_print);
344 }
345 else
346 {
347 printf_filtered (_("%s %s in %s %s will be skipped"
348 " when stepping.\n"),
349 function_text, function_to_print,
350 lower_file_text, file_to_print);
351 }
352 }
353 }
354
355 static void
356 info_skip_command (const char *arg, int from_tty)
357 {
358 int num_printable_entries = 0;
359 struct value_print_options opts;
360
361 get_user_print_options (&opts);
362
363 /* Count the number of rows in the table and see if we need space for a
364 64-bit address anywhere. */
365 for (const skiplist_entry &e : skiplist_entries)
366 if (arg == NULL || number_is_in_list (arg, e.number ()))
367 num_printable_entries++;
368
369 if (num_printable_entries == 0)
370 {
371 if (arg == NULL)
372 current_uiout->message (_("Not skipping any files or functions.\n"));
373 else
374 current_uiout->message (
375 _("No skiplist entries found with number %s.\n"), arg);
376
377 return;
378 }
379
380 ui_out_emit_table table_emitter (current_uiout, 6, num_printable_entries,
381 "SkiplistTable");
382
383 current_uiout->table_header (5, ui_left, "number", "Num"); /* 1 */
384 current_uiout->table_header (3, ui_left, "enabled", "Enb"); /* 2 */
385 current_uiout->table_header (4, ui_right, "regexp", "Glob"); /* 3 */
386 current_uiout->table_header (20, ui_left, "file", "File"); /* 4 */
387 current_uiout->table_header (2, ui_right, "regexp", "RE"); /* 5 */
388 current_uiout->table_header (40, ui_noalign, "function", "Function"); /* 6 */
389 current_uiout->table_body ();
390
391 for (const skiplist_entry &e : skiplist_entries)
392 {
393 QUIT;
394 if (arg != NULL && !number_is_in_list (arg, e.number ()))
395 continue;
396
397 ui_out_emit_tuple tuple_emitter (current_uiout, "blklst-entry");
398 current_uiout->field_int ("number", e.number ()); /* 1 */
399
400 if (e.enabled ())
401 current_uiout->field_string ("enabled", "y"); /* 2 */
402 else
403 current_uiout->field_string ("enabled", "n"); /* 2 */
404
405 if (e.file_is_glob ())
406 current_uiout->field_string ("regexp", "y"); /* 3 */
407 else
408 current_uiout->field_string ("regexp", "n"); /* 3 */
409
410 current_uiout->field_string ("file",
411 e.file ().empty () ? "<none>"
412 : e.file ().c_str ()); /* 4 */
413 if (e.function_is_regexp ())
414 current_uiout->field_string ("regexp", "y"); /* 5 */
415 else
416 current_uiout->field_string ("regexp", "n"); /* 5 */
417
418 current_uiout->field_string ("function",
419 e.function ().empty () ? "<none>"
420 : e.function ().c_str ()); /* 6 */
421
422 current_uiout->text ("\n");
423 }
424 }
425
426 static void
427 skip_enable_command (const char *arg, int from_tty)
428 {
429 bool found = false;
430
431 for (skiplist_entry &e : skiplist_entries)
432 if (arg == NULL || number_is_in_list (arg, e.number ()))
433 {
434 e.enable ();
435 found = true;
436 }
437
438 if (!found)
439 error (_("No skiplist entries found with number %s."), arg);
440 }
441
442 static void
443 skip_disable_command (const char *arg, int from_tty)
444 {
445 bool found = false;
446
447 for (skiplist_entry &e : skiplist_entries)
448 if (arg == NULL || number_is_in_list (arg, e.number ()))
449 {
450 e.disable ();
451 found = true;
452 }
453
454 if (!found)
455 error (_("No skiplist entries found with number %s."), arg);
456 }
457
458 static void
459 skip_delete_command (const char *arg, int from_tty)
460 {
461 bool found = false;
462
463 for (auto it = skiplist_entries.begin (),
464 end = skiplist_entries.end ();
465 it != end;)
466 {
467 const skiplist_entry &e = *it;
468
469 if (arg == NULL || number_is_in_list (arg, e.number ()))
470 {
471 it = skiplist_entries.erase (it);
472 found = true;
473 }
474 else
475 ++it;
476 }
477
478 if (!found)
479 error (_("No skiplist entries found with number %s."), arg);
480 }
481
482 bool
483 skiplist_entry::do_skip_file_p (const symtab_and_line &function_sal) const
484 {
485 /* Check first sole SYMTAB->FILENAME. It may not be a substring of
486 symtab_to_fullname as it may contain "./" etc. */
487 if (compare_filenames_for_search (function_sal.symtab->filename,
488 m_file.c_str ()))
489 return true;
490
491 /* Before we invoke realpath, which can get expensive when many
492 files are involved, do a quick comparison of the basenames. */
493 if (!basenames_may_differ
494 && filename_cmp (lbasename (function_sal.symtab->filename),
495 lbasename (m_file.c_str ())) != 0)
496 return false;
497
498 /* Note: symtab_to_fullname caches its result, thus we don't have to. */
499 {
500 const char *fullname = symtab_to_fullname (function_sal.symtab);
501
502 if (compare_filenames_for_search (fullname, m_file.c_str ()))
503 return true;
504 }
505
506 return false;
507 }
508
509 bool
510 skiplist_entry::do_skip_gfile_p (const symtab_and_line &function_sal) const
511 {
512 /* Check first sole SYMTAB->FILENAME. It may not be a substring of
513 symtab_to_fullname as it may contain "./" etc. */
514 if (gdb_filename_fnmatch (m_file.c_str (), function_sal.symtab->filename,
515 FNM_FILE_NAME | FNM_NOESCAPE) == 0)
516 return true;
517
518 /* Before we invoke symtab_to_fullname, which is expensive, do a quick
519 comparison of the basenames.
520 Note that we assume that lbasename works with glob-style patterns.
521 If the basename of the glob pattern is something like "*.c" then this
522 isn't much of a win. Oh well. */
523 if (!basenames_may_differ
524 && gdb_filename_fnmatch (lbasename (m_file.c_str ()),
525 lbasename (function_sal.symtab->filename),
526 FNM_FILE_NAME | FNM_NOESCAPE) != 0)
527 return false;
528
529 /* Note: symtab_to_fullname caches its result, thus we don't have to. */
530 {
531 const char *fullname = symtab_to_fullname (function_sal.symtab);
532
533 if (compare_glob_filenames_for_search (fullname, m_file.c_str ()))
534 return true;
535 }
536
537 return false;
538 }
539
540 bool
541 skiplist_entry::skip_file_p (const symtab_and_line &function_sal) const
542 {
543 if (m_file.empty ())
544 return false;
545
546 if (function_sal.symtab == NULL)
547 return false;
548
549 if (m_file_is_glob)
550 return do_skip_gfile_p (function_sal);
551 else
552 return do_skip_file_p (function_sal);
553 }
554
555 bool
556 skiplist_entry::skip_function_p (const char *function_name) const
557 {
558 if (m_function.empty ())
559 return false;
560
561 if (m_function_is_regexp)
562 {
563 gdb_assert (m_compiled_function_regexp);
564 return (m_compiled_function_regexp->exec (function_name, 0, NULL, 0)
565 == 0);
566 }
567 else
568 return strcmp_iw (function_name, m_function.c_str ()) == 0;
569 }
570
571 /* See skip.h. */
572
573 bool
574 function_name_is_marked_for_skip (const char *function_name,
575 const symtab_and_line &function_sal)
576 {
577 if (function_name == NULL)
578 return false;
579
580 for (const skiplist_entry &e : skiplist_entries)
581 {
582 if (!e.enabled ())
583 continue;
584
585 bool skip_by_file = e.skip_file_p (function_sal);
586 bool skip_by_function = e.skip_function_p (function_name);
587
588 /* If both file and function must match, make sure we don't errantly
589 exit if only one of them match. */
590 if (!e.file ().empty () && !e.function ().empty ())
591 {
592 if (skip_by_file && skip_by_function)
593 return true;
594 }
595 /* Only one of file/function is specified. */
596 else if (skip_by_file || skip_by_function)
597 return true;
598 }
599
600 return false;
601 }
602
603 void
604 _initialize_step_skip (void)
605 {
606 static struct cmd_list_element *skiplist = NULL;
607 struct cmd_list_element *c;
608
609 add_prefix_cmd ("skip", class_breakpoint, skip_command, _("\
610 Ignore a function while stepping.\n\
611 \n\
612 Usage: skip [FUNCTION-NAME]\n\
613 skip [<file-spec>] [<function-spec>]\n\
614 If no arguments are given, ignore the current function.\n\
615 \n\
616 <file-spec> is one of:\n\
617 -fi|-file FILE-NAME\n\
618 -gfi|-gfile GLOB-FILE-PATTERN\n\
619 <function-spec> is one of:\n\
620 -fu|-function FUNCTION-NAME\n\
621 -rfu|-rfunction FUNCTION-NAME-REGULAR-EXPRESSION"),
622 &skiplist, "skip ", 1, &cmdlist);
623
624 c = add_cmd ("file", class_breakpoint, skip_file_command, _("\
625 Ignore a file while stepping.\n\
626 Usage: skip file [FILE-NAME]\n\
627 If no filename is given, ignore the current file."),
628 &skiplist);
629 set_cmd_completer (c, filename_completer);
630
631 c = add_cmd ("function", class_breakpoint, skip_function_command, _("\
632 Ignore a function while stepping.\n\
633 Usage: skip function [FUNCTION-NAME]\n\
634 If no function name is given, skip the current function."),
635 &skiplist);
636 set_cmd_completer (c, location_completer);
637
638 add_cmd ("enable", class_breakpoint, skip_enable_command, _("\
639 Enable skip entries. You can specify numbers (e.g. \"skip enable 1 3\"), \
640 ranges (e.g. \"skip enable 4-8\"), or both (e.g. \"skip enable 1 3 4-8\").\n\n\
641 If you don't specify any numbers or ranges, we'll enable all skip entries.\n\n\
642 Usage: skip enable [NUMBERS AND/OR RANGES]"),
643 &skiplist);
644
645 add_cmd ("disable", class_breakpoint, skip_disable_command, _("\
646 Disable skip entries. You can specify numbers (e.g. \"skip disable 1 3\"), \
647 ranges (e.g. \"skip disable 4-8\"), or both (e.g. \"skip disable 1 3 4-8\").\n\n\
648 If you don't specify any numbers or ranges, we'll disable all skip entries.\n\n\
649 Usage: skip disable [NUMBERS AND/OR RANGES]"),
650 &skiplist);
651
652 add_cmd ("delete", class_breakpoint, skip_delete_command, _("\
653 Delete skip entries. You can specify numbers (e.g. \"skip delete 1 3\"), \
654 ranges (e.g. \"skip delete 4-8\"), or both (e.g. \"skip delete 1 3 4-8\").\n\n\
655 If you don't specify any numbers or ranges, we'll delete all skip entries.\n\n\
656 Usage: skip delete [NUMBERS AND/OR RANGES]"),
657 &skiplist);
658
659 add_info ("skip", info_skip_command, _("\
660 Display the status of skips. You can specify numbers (e.g. \"skip info 1 3\"), \
661 ranges (e.g. \"skip info 4-8\"), or both (e.g. \"skip info 1 3 4-8\").\n\n\
662 If you don't specify any numbers or ranges, we'll show all skips.\n\n\
663 Usage: skip info [NUMBERS AND/OR RANGES]\n\
664 The \"Type\" column indicates one of:\n\
665 \tfile - ignored file\n\
666 \tfunction - ignored function"));
667 }
get_last_displayed_addr
CORE_ADDR get_last_displayed_addr(void)
Definition: stack.c:989
string
const char * string
Definition: signals.c:50
skiplist_entry::skip_file_p
bool skip_file_p(const symtab_and_line &function_sal) const
Definition: skip.c:541
skiplist_entry::m_enabled
bool m_enabled
Definition: skip.c:113
skiplist_entry::disable
void disable()
Definition: skip.c:67
_initialize_step_skip
void _initialize_step_skip(void)
Definition: skip.c:604
completer.h
skiplist_entry::m_function_is_regexp
bool m_function_is_regexp
Definition: skip.c:104
ui_right
Definition: ui-out.h:46
skiplist_entry::skip_function_p
bool skip_function_p(const char *function_name) const
Definition: skip.c:556
info_skip_command
static void info_skip_command(const char *arg, int from_tty)
Definition: skip.c:356
skiplist_entry::enable
void enable()
Definition: skip.c:66
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
ui_out_emit_type
Definition: ui-out.h:192
skip_disable_command
static void skip_disable_command(const char *arg, int from_tty)
Definition: skip.c:443
command.h
skiplist_entry::m_compiled_function_regexp
gdb::optional< compiled_regex > m_compiled_function_regexp
Definition: skip.c:110
strcmp_iw
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2517
cmd_list_element
Definition: cli-decode.h:46
number_is_in_list
int number_is_in_list(const char *list, int number)
Definition: cli-utils.c:227
gdb_regex.h
compare_filenames_for_search
int compare_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:318
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
compare_glob_filenames_for_search
int compare_glob_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:356
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
filename_completer
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:152
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
symtab::filename
const char * filename
Definition: symtab.h:1309
_
#define _(String)
Definition: gdb_locale.h:35
ui_left
Definition: ui-out.h:44
defs.h
skiplist_entry::file_is_glob
bool file_is_glob() const
Definition: skip.c:60
skiplist_entry::add_entry
static void add_entry(bool file_is_glob, std::string &&file, bool function_is_regexp, std::string &&function)
Definition: skip.c:150
highest_skiplist_entry_num
static int highest_skiplist_entry_num
Definition: skip.c:117
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
arch-utils.h
symtab_to_fullname
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
function_name_is_marked_for_skip
bool function_name_is_marked_for_skip(const char *function_name, const symtab_and_line &function_sal)
Definition: skip.c:574
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
skiplist_entry
Definition: skip.c:40
symtab.h
gdb_argv
Definition: utils.h:128
name
const char *const name
Definition: aarch64-tdep.c:76
gdb_optional.h
value_print_options
Definition: valprint.h:25
skiplist_entry::function_is_regexp
bool function_is_regexp() const
Definition: skip.c:63
skiplist_entry::private_key
Definition: skip.c:75
set_cmd_completer
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:160
skiplist_entries
static std::list< skiplist_entry > skiplist_entries
Definition: skip.c:116
cli-utils.h
current_uiout
#define current_uiout
Definition: ui-out.h:39
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
skiplist_entry::do_skip_file_p
bool do_skip_file_p(const symtab_and_line &function_sal) const
Definition: skip.c:483
skip_enable_command
static void skip_enable_command(const char *arg, int from_tty)
Definition: skip.c:427
get_current_arch
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:798
skip.h
linespec.h
ui_noalign
Definition: ui-out.h:47
breakpoint.h
symtab
Definition: symtab.h:1291
basenames_may_differ
int basenames_may_differ
Definition: symtab.c:231
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
get_last_displayed_symtab
struct symtab * get_last_displayed_symtab(void)
Definition: stack.c:999
value
Definition: value.c:169
location_completer
void location_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: completer.c:828
symtab_and_line
Definition: symtab.h:1746
skiplist_entry::skiplist_entry
skiplist_entry(const skiplist_entry &)=delete
skiplist_entry::operator=
void operator=(const skiplist_entry &)=delete
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
last_displayed_sal_is_valid
int last_displayed_sal_is_valid(void)
Definition: stack.c:971
skip_function
static void skip_function(const char *name)
Definition: skip.c:194
source.h
gdb::optional< compiled_regex >
skip_command
static void skip_command(const char *arg, int from_tty)
Definition: skip.c:229
class_breakpoint
Definition: command.h:42
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
skiplist_entry::do_skip_gfile_p
bool do_skip_gfile_p(const symtab_and_line &function_sal) const
Definition: skip.c:510
skiplist_entry::m_number
int m_number
Definition: skip.c:92
value.h
gdb_filename_fnmatch
int gdb_filename_fnmatch(const char *pattern, const char *string, int flags)
Definition: utils.c:3321
skip_file_command
static void skip_file_command(const char *arg, int from_tty)
Definition: skip.c:164
skiplist_entry::number
int number() const
Definition: skip.c:58
skiplist_entry::m_function
std::string m_function
Definition: skip.c:107
skiplist_entry::enabled
bool enabled() const
Definition: skip.c:59
gdb.argv
argv
Definition: __init__.py:63
skiplist_entry::m_file_is_glob
bool m_file_is_glob
Definition: skip.c:96
skip_delete_command
static void skip_delete_command(const char *arg, int from_tty)
Definition: skip.c:459
QUIT
#define QUIT
Definition: defs.h:179
skip_function_command
static void skip_function_command(const char *arg, int from_tty)
Definition: skip.c:202
valprint.h
stack.h
gdbcmd.h
ui_out_emit_table
Definition: ui-out.h:219
error
void error(const char *fmt,...)
Definition: errors.c:38
skiplist_entry::m_file
std::string m_file
Definition: skip.c:99
skiplist_entry::file
const std::string & file() const
Definition: skip.c:61
ui-out.h
compiled_regex::exec
int exec(const char *string, size_t nmatch, regmatch_t pmatch[], int eflags) const
Definition: gdb_regex.c:45