Automatic date update in version.in
[external/binutils.git] / gdb / skip.c
1 /* Skipping uninteresting files and functions while stepping.
2
3    Copyright (C) 2011-2019 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 /* True if we want to print debug printouts related to file/function
41    skipping. */
42 static int debug_skip = 0;
43
44 class skiplist_entry
45 {
46 public:
47   /* Create a skiplist_entry object and add it to the chain.  */
48   static void add_entry (bool file_is_glob,
49                          std::string &&file,
50                          bool function_is_regexp,
51                          std::string &&function);
52
53   /* Return true if the skip entry has a file or glob-style file
54      pattern that matches FUNCTION_SAL.  */
55   bool skip_file_p (const symtab_and_line &function_sal) const;
56
57   /* Return true if the skip entry has a function or function regexp
58      that matches FUNCTION_NAME.  */
59   bool skip_function_p (const char *function_name) const;
60
61   /* Getters.  */
62   int number () const { return m_number; };
63   bool enabled () const { return m_enabled; };
64   bool file_is_glob () const { return m_file_is_glob; }
65   const std::string &file () const { return m_file; }
66   const std::string &function () const { return m_function; }
67   bool function_is_regexp () const { return m_function_is_regexp; }
68
69   /* Setters.  */
70   void enable () { m_enabled = true; };
71   void disable () { m_enabled = false; };
72
73   /* Disable copy.  */
74   skiplist_entry (const skiplist_entry &) = delete;
75   void operator= (const skiplist_entry &) = delete;
76
77 private:
78   /* Key that grants access to the constructor.  */
79   struct private_key {};
80 public:
81   /* Public so we can construct with container::emplace_back.  Since
82      it requires a private class key, it can't be called from outside.
83      Use the add_entry static factory method to construct instead.  */
84   skiplist_entry (bool file_is_glob, std::string &&file,
85                   bool function_is_regexp, std::string &&function,
86                   private_key);
87
88 private:
89   /* Return true if we're stopped at a file to be skipped.  */
90   bool do_skip_file_p (const symtab_and_line &function_sal) const;
91
92   /* Return true if we're stopped at a globbed file to be skipped.  */
93   bool do_skip_gfile_p (const symtab_and_line &function_sal) const;
94
95 private: /* data */
96   int m_number = -1;
97
98   /* True if FILE is a glob-style pattern.
99      Otherwise it is the plain file name (possibly with directories).  */
100   bool m_file_is_glob;
101
102   /* The name of the file or empty if no name.  */
103   std::string m_file;
104
105   /* True if FUNCTION is a regexp.
106      Otherwise it is a plain function name (possibly with arguments,
107      for C++).  */
108   bool m_function_is_regexp;
109
110   /* The name of the function or empty if no name.  */
111   std::string m_function;
112
113   /* If this is a function regexp, the compiled form.  */
114   gdb::optional<compiled_regex> m_compiled_function_regexp;
115
116   /* Enabled/disabled state.  */
117   bool m_enabled = true;
118 };
119
120 static std::list<skiplist_entry> skiplist_entries;
121 static int highest_skiplist_entry_num = 0;
122
123 skiplist_entry::skiplist_entry (bool file_is_glob,
124                                 std::string &&file,
125                                 bool function_is_regexp,
126                                 std::string &&function,
127                                 private_key)
128   : m_file_is_glob (file_is_glob),
129     m_file (std::move (file)),
130     m_function_is_regexp (function_is_regexp),
131     m_function (std::move (function))
132 {
133   gdb_assert (!m_file.empty () || !m_function.empty ());
134
135   if (m_file_is_glob)
136     gdb_assert (!m_file.empty ());
137
138   if (m_function_is_regexp)
139     {
140       gdb_assert (!m_function.empty ());
141
142       int flags = REG_NOSUB;
143 #ifdef REG_EXTENDED
144       flags |= REG_EXTENDED;
145 #endif
146
147       gdb_assert (!m_function.empty ());
148       m_compiled_function_regexp.emplace (m_function.c_str (), flags,
149                                           _("regexp"));
150     }
151 }
152
153 void
154 skiplist_entry::add_entry (bool file_is_glob, std::string &&file,
155                            bool function_is_regexp, std::string &&function)
156 {
157   skiplist_entries.emplace_back (file_is_glob,
158                                  std::move (file),
159                                  function_is_regexp,
160                                  std::move (function),
161                                  private_key {});
162
163   /* Incremented after push_back, in case push_back throws.  */
164   skiplist_entries.back ().m_number = ++highest_skiplist_entry_num;
165 }
166
167 static void
168 skip_file_command (const char *arg, int from_tty)
169 {
170   struct symtab *symtab;
171   const char *filename = NULL;
172
173   /* If no argument was given, try to default to the last
174      displayed codepoint.  */
175   if (arg == NULL)
176     {
177       symtab = get_last_displayed_symtab ();
178       if (symtab == NULL)
179         error (_("No default file now."));
180
181       /* It is not a typo, symtab_to_filename_for_display woule be needlessly
182          ambiguous.  */
183       filename = symtab_to_fullname (symtab);
184     }
185   else
186     filename = arg;
187
188   skiplist_entry::add_entry (false, std::string (filename),
189                              false, std::string ());
190
191   printf_filtered (_("File %s will be skipped when stepping.\n"), filename);
192 }
193
194 /* Create a skiplist entry for the given function NAME and add it to the
195    list.  */
196
197 static void
198 skip_function (const char *name)
199 {
200   skiplist_entry::add_entry (false, std::string (), false, std::string (name));
201
202   printf_filtered (_("Function %s will be skipped when stepping.\n"), name);
203 }
204
205 static void
206 skip_function_command (const char *arg, int from_tty)
207 {
208   /* Default to the current function if no argument is given.  */
209   if (arg == NULL)
210     {
211       const char *name = NULL;
212       CORE_ADDR pc;
213
214       if (!last_displayed_sal_is_valid ())
215         error (_("No default function now."));
216
217       pc = get_last_displayed_addr ();
218       if (!find_pc_partial_function (pc, &name, NULL, NULL))
219         {
220           error (_("No function found containing current program point %s."),
221                   paddress (get_current_arch (), pc));
222         }
223       skip_function (name);
224       return;
225     }
226
227   skip_function (arg);
228 }
229
230 /* Process "skip ..." that does not match "skip file" or "skip function".  */
231
232 static void
233 skip_command (const char *arg, int from_tty)
234 {
235   const char *file = NULL;
236   const char *gfile = NULL;
237   const char *function = NULL;
238   const char *rfunction = NULL;
239   int i;
240
241   if (arg == NULL)
242     {
243       skip_function_command (arg, from_tty);
244       return;
245     }
246
247   gdb_argv argv (arg);
248
249   for (i = 0; argv[i] != NULL; ++i)
250     {
251       const char *p = argv[i];
252       const char *value = argv[i + 1];
253
254       if (strcmp (p, "-fi") == 0
255           || strcmp (p, "-file") == 0)
256         {
257           if (value == NULL)
258             error (_("Missing value for %s option."), p);
259           file = value;
260           ++i;
261         }
262       else if (strcmp (p, "-gfi") == 0
263                || strcmp (p, "-gfile") == 0)
264         {
265           if (value == NULL)
266             error (_("Missing value for %s option."), p);
267           gfile = value;
268           ++i;
269         }
270       else if (strcmp (p, "-fu") == 0
271                || strcmp (p, "-function") == 0)
272         {
273           if (value == NULL)
274             error (_("Missing value for %s option."), p);
275           function = value;
276           ++i;
277         }
278       else if (strcmp (p, "-rfu") == 0
279                || strcmp (p, "-rfunction") == 0)
280         {
281           if (value == NULL)
282             error (_("Missing value for %s option."), p);
283           rfunction = value;
284           ++i;
285         }
286       else if (*p == '-')
287         error (_("Invalid skip option: %s"), p);
288       else if (i == 0)
289         {
290           /* Assume the user entered "skip FUNCTION-NAME".
291              FUNCTION-NAME may be `foo (int)', and therefore we pass the
292              complete original arg to skip_function command as if the user
293              typed "skip function arg".  */
294           skip_function_command (arg, from_tty);
295           return;
296         }
297       else
298         error (_("Invalid argument: %s"), p);
299     }
300
301   if (file != NULL && gfile != NULL)
302     error (_("Cannot specify both -file and -gfile."));
303
304   if (function != NULL && rfunction != NULL)
305     error (_("Cannot specify both -function and -rfunction."));
306
307   /* This shouldn't happen as "skip" by itself gets punted to
308      skip_function_command.  */
309   gdb_assert (file != NULL || gfile != NULL
310               || function != NULL || rfunction != NULL);
311
312   std::string entry_file;
313   if (file != NULL)
314     entry_file = file;
315   else if (gfile != NULL)
316     entry_file = gfile;
317
318   std::string entry_function;
319   if (function != NULL)
320     entry_function = function;
321   else if (rfunction != NULL)
322     entry_function = rfunction;
323
324   skiplist_entry::add_entry (gfile != NULL, std::move (entry_file),
325                              rfunction != NULL, std::move (entry_function));
326
327   /* I18N concerns drive some of the choices here (we can't piece together
328      the output too much).  OTOH we want to keep this simple.  Therefore the
329      only polish we add to the output is to append "(s)" to "File" or
330      "Function" if they're a glob/regexp.  */
331   {
332     const char *file_to_print = file != NULL ? file : gfile;
333     const char *function_to_print = function != NULL ? function : rfunction;
334     const char *file_text = gfile != NULL ? _("File(s)") : _("File");
335     const char *lower_file_text = gfile != NULL ? _("file(s)") : _("file");
336     const char *function_text
337       = rfunction != NULL ? _("Function(s)") : _("Function");
338
339     if (function_to_print == NULL)
340       {
341         printf_filtered (_("%s %s will be skipped when stepping.\n"),
342                          file_text, file_to_print);
343       }
344     else if (file_to_print == NULL)
345       {
346         printf_filtered (_("%s %s will be skipped when stepping.\n"),
347                          function_text, function_to_print);
348       }
349     else
350       {
351         printf_filtered (_("%s %s in %s %s will be skipped"
352                            " when stepping.\n"),
353                          function_text, function_to_print,
354                          lower_file_text, file_to_print);
355       }
356   }
357 }
358
359 static void
360 info_skip_command (const char *arg, int from_tty)
361 {
362   int num_printable_entries = 0;
363   struct value_print_options opts;
364
365   get_user_print_options (&opts);
366
367   /* Count the number of rows in the table and see if we need space for a
368      64-bit address anywhere.  */
369   for (const skiplist_entry &e : skiplist_entries)
370     if (arg == NULL || number_is_in_list (arg, e.number ()))
371       num_printable_entries++;
372
373   if (num_printable_entries == 0)
374     {
375       if (arg == NULL)
376         current_uiout->message (_("Not skipping any files or functions.\n"));
377       else
378         current_uiout->message (
379           _("No skiplist entries found with number %s.\n"), arg);
380
381       return;
382     }
383
384   ui_out_emit_table table_emitter (current_uiout, 6, num_printable_entries,
385                                    "SkiplistTable");
386
387   current_uiout->table_header (5, ui_left, "number", "Num");   /* 1 */
388   current_uiout->table_header (3, ui_left, "enabled", "Enb");  /* 2 */
389   current_uiout->table_header (4, ui_right, "regexp", "Glob"); /* 3 */
390   current_uiout->table_header (20, ui_left, "file", "File");   /* 4 */
391   current_uiout->table_header (2, ui_right, "regexp", "RE");   /* 5 */
392   current_uiout->table_header (40, ui_noalign, "function", "Function"); /* 6 */
393   current_uiout->table_body ();
394
395   for (const skiplist_entry &e : skiplist_entries)
396     {
397       QUIT;
398       if (arg != NULL && !number_is_in_list (arg, e.number ()))
399         continue;
400
401       ui_out_emit_tuple tuple_emitter (current_uiout, "blklst-entry");
402       current_uiout->field_int ("number", e.number ()); /* 1 */
403
404       if (e.enabled ())
405         current_uiout->field_string ("enabled", "y"); /* 2 */
406       else
407         current_uiout->field_string ("enabled", "n"); /* 2 */
408
409       if (e.file_is_glob ())
410         current_uiout->field_string ("regexp", "y"); /* 3 */
411       else
412         current_uiout->field_string ("regexp", "n"); /* 3 */
413
414       current_uiout->field_string ("file",
415                                    e.file ().empty () ? "<none>"
416                                    : e.file ().c_str (),
417                                    ui_out_style_kind::FILE); /* 4 */
418       if (e.function_is_regexp ())
419         current_uiout->field_string ("regexp", "y"); /* 5 */
420       else
421         current_uiout->field_string ("regexp", "n"); /* 5 */
422
423       current_uiout->field_string ("function",
424                                    e.function ().empty () ? "<none>"
425                                    : e.function ().c_str (),
426                                    ui_out_style_kind::FUNCTION); /* 6 */
427
428       current_uiout->text ("\n");
429     }
430 }
431
432 static void
433 skip_enable_command (const char *arg, int from_tty)
434 {
435   bool found = false;
436
437   for (skiplist_entry &e : skiplist_entries)
438     if (arg == NULL || number_is_in_list (arg, e.number ()))
439       {
440         e.enable ();
441         found = true;
442       }
443
444   if (!found)
445     error (_("No skiplist entries found with number %s."), arg);
446 }
447
448 static void
449 skip_disable_command (const char *arg, int from_tty)
450 {
451   bool found = false;
452
453   for (skiplist_entry &e : skiplist_entries)
454     if (arg == NULL || number_is_in_list (arg, e.number ()))
455       {
456         e.disable ();
457         found = true;
458       }
459
460   if (!found)
461     error (_("No skiplist entries found with number %s."), arg);
462 }
463
464 static void
465 skip_delete_command (const char *arg, int from_tty)
466 {
467   bool found = false;
468
469   for (auto it = skiplist_entries.begin (),
470          end = skiplist_entries.end ();
471        it != end;)
472     {
473       const skiplist_entry &e = *it;
474
475       if (arg == NULL || number_is_in_list (arg, e.number ()))
476         {
477           it = skiplist_entries.erase (it);
478           found = true;
479         }
480       else
481         ++it;
482     }
483
484   if (!found)
485     error (_("No skiplist entries found with number %s."), arg);
486 }
487
488 bool
489 skiplist_entry::do_skip_file_p (const symtab_and_line &function_sal) const
490 {
491   if (debug_skip)
492     fprintf_unfiltered (gdb_stdlog,
493                         "skip: checking if file %s matches non-glob %s...",
494                         function_sal.symtab->filename, m_file.c_str ());
495
496   bool result;
497
498   /* Check first sole SYMTAB->FILENAME.  It may not be a substring of
499      symtab_to_fullname as it may contain "./" etc.  */
500   if (compare_filenames_for_search (function_sal.symtab->filename,
501                                     m_file.c_str ()))
502     result = true;
503
504   /* Before we invoke realpath, which can get expensive when many
505      files are involved, do a quick comparison of the basenames.  */
506   else if (!basenames_may_differ
507            && filename_cmp (lbasename (function_sal.symtab->filename),
508                             lbasename (m_file.c_str ())) != 0)
509     result = false;
510   else
511     {
512       /* Note: symtab_to_fullname caches its result, thus we don't have to.  */
513       const char *fullname = symtab_to_fullname (function_sal.symtab);
514
515       result = compare_filenames_for_search (fullname, m_file.c_str ());
516     }
517
518   if (debug_skip)
519     fprintf_unfiltered (gdb_stdlog, result ? "yes.\n" : "no.\n");
520
521   return result;
522 }
523
524 bool
525 skiplist_entry::do_skip_gfile_p (const symtab_and_line &function_sal) const
526 {
527   if (debug_skip)
528     fprintf_unfiltered (gdb_stdlog,
529                         "skip: checking if file %s matches glob %s...",
530                         function_sal.symtab->filename, m_file.c_str ());
531
532   bool result;
533
534   /* Check first sole SYMTAB->FILENAME.  It may not be a substring of
535      symtab_to_fullname as it may contain "./" etc.  */
536   if (gdb_filename_fnmatch (m_file.c_str (), function_sal.symtab->filename,
537                             FNM_FILE_NAME | FNM_NOESCAPE) == 0)
538     result = true;
539
540   /* Before we invoke symtab_to_fullname, which is expensive, do a quick
541      comparison of the basenames.
542      Note that we assume that lbasename works with glob-style patterns.
543      If the basename of the glob pattern is something like "*.c" then this
544      isn't much of a win.  Oh well.  */
545   else if (!basenames_may_differ
546       && gdb_filename_fnmatch (lbasename (m_file.c_str ()),
547                                lbasename (function_sal.symtab->filename),
548                                FNM_FILE_NAME | FNM_NOESCAPE) != 0)
549     result = false;
550   else
551     {
552       /* Note: symtab_to_fullname caches its result, thus we don't have to.  */
553       const char *fullname = symtab_to_fullname (function_sal.symtab);
554
555       result = compare_glob_filenames_for_search (fullname, m_file.c_str ());
556     }
557
558   if (debug_skip)
559     fprintf_unfiltered (gdb_stdlog, result ? "yes.\n" : "no.\n");
560
561   return result;
562 }
563
564 bool
565 skiplist_entry::skip_file_p (const symtab_and_line &function_sal) const
566 {
567   if (m_file.empty ())
568     return false;
569
570   if (function_sal.symtab == NULL)
571     return false;
572
573   if (m_file_is_glob)
574     return do_skip_gfile_p (function_sal);
575   else
576     return do_skip_file_p (function_sal);
577 }
578
579 bool
580 skiplist_entry::skip_function_p (const char *function_name) const
581 {
582   if (m_function.empty ())
583     return false;
584
585   bool result;
586
587   if (m_function_is_regexp)
588     {
589       if (debug_skip)
590         fprintf_unfiltered (gdb_stdlog,
591                             "skip: checking if function %s matches regex %s...",
592                             function_name, m_function.c_str ());
593
594       gdb_assert (m_compiled_function_regexp);
595       result
596         = (m_compiled_function_regexp->exec (function_name, 0, NULL, 0) == 0);
597     }
598   else
599     {
600       if (debug_skip)
601         fprintf_unfiltered (gdb_stdlog,
602                             ("skip: checking if function %s matches non-regex "
603                              "%s..."),
604                             function_name, m_function.c_str ());
605       result = (strcmp_iw (function_name, m_function.c_str ()) == 0);
606     }
607
608   if (debug_skip)
609     fprintf_unfiltered (gdb_stdlog, result ? "yes.\n" : "no.\n");
610
611   return result;
612 }
613
614 /* See skip.h.  */
615
616 bool
617 function_name_is_marked_for_skip (const char *function_name,
618                                   const symtab_and_line &function_sal)
619 {
620   if (function_name == NULL)
621     return false;
622
623   for (const skiplist_entry &e : skiplist_entries)
624     {
625       if (!e.enabled ())
626         continue;
627
628       bool skip_by_file = e.skip_file_p (function_sal);
629       bool skip_by_function = e.skip_function_p (function_name);
630
631       /* If both file and function must match, make sure we don't errantly
632          exit if only one of them match.  */
633       if (!e.file ().empty () && !e.function ().empty ())
634         {
635           if (skip_by_file && skip_by_function)
636             return true;
637         }
638       /* Only one of file/function is specified.  */
639       else if (skip_by_file || skip_by_function)
640         return true;
641     }
642
643   return false;
644 }
645
646 /* Completer for skip numbers.  */
647
648 static void
649 complete_skip_number (cmd_list_element *cmd,
650                       completion_tracker &completer,
651                       const char *text, const char *word)
652 {
653   size_t word_len = strlen (word);
654
655   for (const skiplist_entry &entry : skiplist_entries)
656     {
657       gdb::unique_xmalloc_ptr<char> name (xstrprintf ("%d", entry.number ()));
658       if (strncmp (word, name.get (), word_len) == 0)
659         completer.add_completion (std::move (name));
660     }
661 }
662
663 void
664 _initialize_step_skip (void)
665 {
666   static struct cmd_list_element *skiplist = NULL;
667   struct cmd_list_element *c;
668
669   add_prefix_cmd ("skip", class_breakpoint, skip_command, _("\
670 Ignore a function while stepping.\n\
671 \n\
672 Usage: skip [FUNCTION-NAME]\n\
673        skip [FILE-SPEC] [FUNCTION-SPEC]\n\
674 If no arguments are given, ignore the current function.\n\
675 \n\
676 FILE-SPEC is one of:\n\
677        -fi|-file FILE-NAME\n\
678        -gfi|-gfile GLOB-FILE-PATTERN\n\
679 FUNCTION-SPEC is one of:\n\
680        -fu|-function FUNCTION-NAME\n\
681        -rfu|-rfunction FUNCTION-NAME-REGULAR-EXPRESSION"),
682                   &skiplist, "skip ", 1, &cmdlist);
683
684   c = add_cmd ("file", class_breakpoint, skip_file_command, _("\
685 Ignore a file while stepping.\n\
686 Usage: skip file [FILE-NAME]\n\
687 If no filename is given, ignore the current file."),
688                &skiplist);
689   set_cmd_completer (c, filename_completer);
690
691   c = add_cmd ("function", class_breakpoint, skip_function_command, _("\
692 Ignore a function while stepping.\n\
693 Usage: skip function [FUNCTION-NAME]\n\
694 If no function name is given, skip the current function."),
695                &skiplist);
696   set_cmd_completer (c, location_completer);
697
698   c = add_cmd ("enable", class_breakpoint, skip_enable_command, _("\
699 Enable skip entries.  You can specify numbers (e.g. \"skip enable 1 3\"), \
700 ranges (e.g. \"skip enable 4-8\"), or both (e.g. \"skip enable 1 3 4-8\").\n\n\
701 If you don't specify any numbers or ranges, we'll enable all skip entries.\n\n\
702 Usage: skip enable [NUMBER | RANGE]..."),
703                &skiplist);
704   set_cmd_completer (c, complete_skip_number);
705
706   c = add_cmd ("disable", class_breakpoint, skip_disable_command, _("\
707 Disable skip entries.  You can specify numbers (e.g. \"skip disable 1 3\"), \
708 ranges (e.g. \"skip disable 4-8\"), or both (e.g. \"skip disable 1 3 4-8\").\n\n\
709 If you don't specify any numbers or ranges, we'll disable all skip entries.\n\n\
710 Usage: skip disable [NUMBER | RANGE]..."),
711                &skiplist);
712   set_cmd_completer (c, complete_skip_number);
713
714   c = add_cmd ("delete", class_breakpoint, skip_delete_command, _("\
715 Delete skip entries.  You can specify numbers (e.g. \"skip delete 1 3\"), \
716 ranges (e.g. \"skip delete 4-8\"), or both (e.g. \"skip delete 1 3 4-8\").\n\n\
717 If you don't specify any numbers or ranges, we'll delete all skip entries.\n\n\
718 Usage: skip delete [NUMBER | RANGES]..."),
719                &skiplist);
720   set_cmd_completer (c, complete_skip_number);
721
722   add_info ("skip", info_skip_command, _("\
723 Display the status of skips.  You can specify numbers (e.g. \"info skip 1 3\"), \
724 ranges (e.g. \"info skip 4-8\"), or both (e.g. \"info skip 1 3 4-8\").\n\n\
725 If you don't specify any numbers or ranges, we'll show all skips.\n\n\
726 Usage: info skip [NUMBER | RANGES]..."));
727   set_cmd_completer (c, complete_skip_number);
728
729   add_setshow_boolean_cmd ("skip", class_maintenance,
730                            &debug_skip, _("\
731 Set whether to print the debug output about skipping files and functions."),
732                            _("\
733 Show whether the debug output about skipping files and functions is printed"),
734                            _("\
735 When non-zero, debug output about skipping files and functions is displayed."),
736                            NULL, NULL,
737                            &setdebuglist, &showdebuglist);
738 }