1 /* Support for GDB maintenance commands.
3 Copyright (C) 1992-2021 Free Software Foundation, Inc.
5 Written by Fred Fish at Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
35 #include "expression.h" /* For language.h */
42 #include "gdbsupport/selftest.h"
45 #include "cli/cli-decode.h"
46 #include "cli/cli-utils.h"
47 #include "cli/cli-setshow.h"
48 #include "cli/cli-cmds.h"
51 #include "gdbsupport/thread-pool.h"
54 static void maintenance_do_deprecate (const char *, int);
58 maintenance_dump_me (const char *args
, int from_tty
)
60 if (query (_("Should GDB dump core? ")))
63 /* SIGQUIT by default is ignored, so use SIGABRT instead. */
64 signal (SIGABRT
, SIG_DFL
);
65 kill (getpid (), SIGABRT
);
67 signal (SIGQUIT
, SIG_DFL
);
68 kill (getpid (), SIGQUIT
);
74 /* Stimulate the internal error mechanism that GDB uses when an
75 internal problem is detected. Allows testing of the mechanism.
76 Also useful when the user wants to drop a core file but not exit
80 maintenance_internal_error (const char *args
, int from_tty
)
82 internal_error (__FILE__
, __LINE__
, "%s", (args
== NULL
? "" : args
));
85 /* Stimulate the internal error mechanism that GDB uses when an
86 internal problem is detected. Allows testing of the mechanism.
87 Also useful when the user wants to drop a core file but not exit
91 maintenance_internal_warning (const char *args
, int from_tty
)
93 internal_warning (__FILE__
, __LINE__
, "%s", (args
== NULL
? "" : args
));
96 /* Stimulate the internal error mechanism that GDB uses when an
97 demangler problem is detected. Allows testing of the mechanism. */
100 maintenance_demangler_warning (const char *args
, int from_tty
)
102 demangler_warning (__FILE__
, __LINE__
, "%s", (args
== NULL
? "" : args
));
105 /* Old command to demangle a string. The command has been moved to "demangle".
106 It is kept for now because otherwise "mt demangle" gets interpreted as
107 "mt demangler-warning" which artificially creates an internal gdb error. */
110 maintenance_demangle (const char *args
, int from_tty
)
112 printf_filtered (_("This command has been moved to \"demangle\".\n"));
116 maintenance_time_display (const char *args
, int from_tty
)
118 if (args
== NULL
|| *args
== '\0')
119 printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
121 set_per_command_time (strtol (args
, NULL
, 10));
125 maintenance_space_display (const char *args
, int from_tty
)
127 if (args
== NULL
|| *args
== '\0')
128 printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
130 set_per_command_space (strtol (args
, NULL
, 10));
133 /* Mini tokenizing lexer for 'maint info sections' command. */
136 match_substring (const char *string
, const char *substr
)
138 int substr_len
= strlen (substr
);
141 while ((tok
= strstr (string
, substr
)) != NULL
)
143 /* Got a partial match. Is it a whole word? */
148 /* Token is delimited at the front... */
149 if (tok
[substr_len
] == ' '
150 || tok
[substr_len
] == '\t'
151 || tok
[substr_len
] == '\0')
153 /* Token is delimited at the rear. Got a whole-word match. */
157 /* Token didn't match as a whole word. Advance and try again. */
163 /* Structure holding information about a single bfd section flag. This is
164 used by the "maintenance info sections" command to print the sections,
165 and for filtering which sections are printed. */
167 struct single_bfd_flag_info
169 /* The name of the section. This is what is printed for the flag, and
170 what the user enter in order to filter by flag. */
173 /* The bfd defined SEC_* flagword value for this flag. */
177 /* Vector of all the known bfd flags. */
179 static const single_bfd_flag_info bfd_flag_info
[] =
181 { "ALLOC", SEC_ALLOC
},
182 { "LOAD", SEC_LOAD
},
183 { "RELOC", SEC_RELOC
},
184 { "READONLY", SEC_READONLY
},
185 { "CODE", SEC_CODE
},
186 { "DATA", SEC_DATA
},
188 { "CONSTRUCTOR", SEC_CONSTRUCTOR
},
189 { "HAS_CONTENTS", SEC_HAS_CONTENTS
},
190 { "NEVER_LOAD", SEC_NEVER_LOAD
},
191 { "COFF_SHARED_LIBRARY", SEC_COFF_SHARED_LIBRARY
},
192 { "IS_COMMON", SEC_IS_COMMON
}
195 /* For each flag in the global BFD_FLAG_INFO list, if FLAGS has a flag's
196 flagword value set, and STRING contains the flag's name then return
197 true, otherwise return false. STRING is never nullptr. */
200 match_bfd_flags (const char *string
, flagword flags
)
202 gdb_assert (string
!= nullptr);
204 for (const auto &f
: bfd_flag_info
)
207 && match_substring (string
, f
.name
))
214 /* Print the names of all flags set in FLAGS. The names are taken from the
215 BFD_FLAG_INFO global. */
218 print_bfd_flags (flagword flags
)
220 for (const auto &f
: bfd_flag_info
)
223 printf_filtered (" %s", f
.name
);
228 maint_print_section_info (const char *name
, flagword flags
,
229 CORE_ADDR addr
, CORE_ADDR endaddr
,
230 unsigned long filepos
, int addr_size
)
232 printf_filtered (" %s", hex_string_custom (addr
, addr_size
));
233 printf_filtered ("->%s", hex_string_custom (endaddr
, addr_size
));
234 printf_filtered (" at %s",
235 hex_string_custom ((unsigned long) filepos
, 8));
236 printf_filtered (": %s", name
);
237 print_bfd_flags (flags
);
238 printf_filtered ("\n");
241 /* Return the number of digits required to display COUNT in decimal.
243 Used when pretty printing index numbers to ensure all of the indexes line
247 index_digits (int count
)
249 return ((int) log10 ((float) count
)) + 1;
252 /* Helper function to pretty-print the section index of ASECT from ABFD.
253 The INDEX_DIGITS is the number of digits in the largest index that will
254 be printed, and is used to pretty-print the resulting string. */
257 print_section_index (bfd
*abfd
,
262 = string_printf (" [%d] ", gdb_bfd_section_index (abfd
, asect
));
263 /* The '+ 4' for the leading and trailing characters. */
264 printf_filtered ("%-*s", (index_digits
+ 4), result
.c_str ());
267 /* Print information about ASECT from ABFD. The section will be printed using
268 the VMA's from the bfd, which will not be the relocated addresses for bfds
269 that should be relocated. The information must be printed with the same
270 layout as PRINT_OBJFILE_SECTION_INFO below.
272 ARG is the argument string passed by the user to the top level maintenance
273 info sections command. Used for filtering which sections are printed. */
276 print_bfd_section_info (bfd
*abfd
, asection
*asect
, const char *arg
,
279 flagword flags
= bfd_section_flags (asect
);
280 const char *name
= bfd_section_name (asect
);
282 if (arg
== NULL
|| *arg
== '\0'
283 || match_substring (arg
, name
)
284 || match_bfd_flags (arg
, flags
))
286 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
287 int addr_size
= gdbarch_addr_bit (gdbarch
) / 8;
288 CORE_ADDR addr
, endaddr
;
290 addr
= bfd_section_vma (asect
);
291 endaddr
= addr
+ bfd_section_size (asect
);
292 print_section_index (abfd
, asect
, index_digits
);
293 maint_print_section_info (name
, flags
, addr
, endaddr
,
294 asect
->filepos
, addr_size
);
298 /* Print information about ASECT which is GDB's wrapper around a section
299 from ABFD. The information must be printed with the same layout as
300 PRINT_BFD_SECTION_INFO above. PRINT_DATA holds information used to
301 filter which sections are printed, and for formatting the output.
303 ARG is the argument string passed by the user to the top level maintenance
304 info sections command. Used for filtering which sections are printed. */
307 print_objfile_section_info (bfd
*abfd
, struct obj_section
*asect
,
308 const char *arg
, int index_digits
)
310 flagword flags
= bfd_section_flags (asect
->the_bfd_section
);
311 const char *name
= bfd_section_name (asect
->the_bfd_section
);
313 if (arg
== NULL
|| *arg
== '\0'
314 || match_substring (arg
, name
)
315 || match_bfd_flags (arg
, flags
))
317 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
318 int addr_size
= gdbarch_addr_bit (gdbarch
) / 8;
320 print_section_index (abfd
, asect
->the_bfd_section
, index_digits
);
321 maint_print_section_info (name
, flags
,
322 obj_section_addr (asect
),
323 obj_section_endaddr (asect
),
324 asect
->the_bfd_section
->filepos
,
329 /* Find an obj_section, GDB's wrapper around a bfd section for ASECTION
330 from ABFD. It might be that no such wrapper exists (for example debug
331 sections don't have such wrappers) in which case nullptr is returned. */
334 maint_obj_section_from_bfd_section (bfd
*abfd
,
338 if (ofile
->sections
== nullptr)
342 = &ofile
->sections
[gdb_bfd_section_index (abfd
, asection
)];
344 if (osect
>= ofile
->sections_end
)
350 /* Print information about all sections from ABFD, which is the bfd
351 corresponding to OBJFILE. It is fine for OBJFILE to be nullptr, but
352 ABFD must never be nullptr. If OBJFILE is provided then the sections of
353 ABFD will (potentially) be displayed relocated (i.e. the object file was
354 loaded with add-symbol-file and custom offsets were provided).
356 HEADER is a string that describes this file, e.g. 'Exec file: ', or
359 ARG is a string used for filtering which sections are printed, this can
360 be nullptr for no filtering. See the top level 'maint info sections'
361 for a fuller description of the possible filtering strings. */
364 maint_print_all_sections (const char *header
, bfd
*abfd
, objfile
*objfile
,
367 puts_filtered (header
);
369 printf_filtered ("`%s', ", bfd_get_filename (abfd
));
371 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
373 int section_count
= gdb_bfd_count_sections (abfd
);
374 int digits
= index_digits (section_count
);
376 for (asection
*sect
: gdb_bfd_sections (abfd
))
378 obj_section
*osect
= nullptr;
380 if (objfile
!= nullptr)
382 gdb_assert (objfile
->sections
!= nullptr);
384 = maint_obj_section_from_bfd_section (abfd
, sect
, objfile
);
385 if (osect
->the_bfd_section
== nullptr)
389 if (osect
== nullptr)
390 print_bfd_section_info (abfd
, sect
, arg
, digits
);
392 print_objfile_section_info (abfd
, osect
, arg
, digits
);
396 /* The options for the "maintenance info sections" command. */
398 struct maint_info_sections_opts
400 /* For "-all-objects". */
401 bool all_objects
= false;
404 static const gdb::option::option_def maint_info_sections_option_defs
[] = {
406 gdb::option::flag_option_def
<maint_info_sections_opts
> {
408 [] (maint_info_sections_opts
*opts
) { return &opts
->all_objects
; },
409 N_("Display information from all loaded object files."),
413 /* Create an option_def_group for the "maintenance info sections" options,
414 with CC_OPTS as context. */
416 static inline gdb::option::option_def_group
417 make_maint_info_sections_options_def_group (maint_info_sections_opts
*cc_opts
)
419 return {{maint_info_sections_option_defs
}, cc_opts
};
422 /* Completion for the "maintenance info sections" command. */
425 maint_info_sections_completer (struct cmd_list_element
*cmd
,
426 completion_tracker
&tracker
,
427 const char *text
, const char * /* word */)
429 /* Complete command options. */
430 const auto group
= make_maint_info_sections_options_def_group (nullptr);
431 if (gdb::option::complete_options
432 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
434 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
436 /* Offer completion for section flags, but not section names. This is
437 only a maintenance command after all, no point going over the top. */
438 std::vector
<const char *> flags
;
439 for (const auto &f
: bfd_flag_info
)
440 flags
.push_back (f
.name
);
441 flags
.push_back (nullptr);
442 complete_on_enum (tracker
, flags
.data (), text
, word
);
445 /* Implement the "maintenance info sections" command. */
448 maintenance_info_sections (const char *arg
, int from_tty
)
450 /* Check if the "-all-objects" flag was passed. */
451 maint_info_sections_opts opts
;
452 const auto group
= make_maint_info_sections_options_def_group (&opts
);
453 gdb::option::process_options
454 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
456 for (objfile
*ofile
: current_program_space
->objfiles ())
458 if (ofile
->obfd
== current_program_space
->exec_bfd ())
459 maint_print_all_sections (_("Exec file: "), ofile
->obfd
, ofile
, arg
);
460 else if (opts
.all_objects
)
461 maint_print_all_sections (_("Object file: "), ofile
->obfd
, ofile
, arg
);
465 maint_print_all_sections (_("Core file: "), core_bfd
, nullptr, arg
);
468 /* Implement the "maintenance info target-sections" command. */
471 maintenance_info_target_sections (const char *arg
, int from_tty
)
475 const target_section_table
*table
476 = target_get_section_table (current_inferior ()->top_target ());
477 if (table
== nullptr)
480 for (const target_section
&sec
: *table
)
482 if (abfd
== nullptr || sec
.the_bfd_section
->owner
!= abfd
)
484 abfd
= sec
.the_bfd_section
->owner
;
485 digits
= std::max (index_digits (gdb_bfd_count_sections (abfd
)),
490 struct gdbarch
*gdbarch
= nullptr;
493 for (const target_section
&sec
: *table
)
495 if (sec
.the_bfd_section
->owner
!= abfd
)
497 abfd
= sec
.the_bfd_section
->owner
;
498 gdbarch
= gdbarch_from_bfd (abfd
);
499 addr_size
= gdbarch_addr_bit (gdbarch
) / 8;
501 printf_filtered (_("From '%s', file type %s:\n"),
502 bfd_get_filename (abfd
), bfd_get_target (abfd
));
504 print_bfd_section_info (abfd
,
508 /* The magic '8 + digits' here ensures that the 'Start' is aligned
509 with the output of print_bfd_section_info. */
510 printf_filtered ("%*sStart: %s, End: %s, Owner token: %p\n",
512 hex_string_custom (sec
.addr
, addr_size
),
513 hex_string_custom (sec
.endaddr
, addr_size
),
519 maintenance_print_statistics (const char *args
, int from_tty
)
521 print_objfile_statistics ();
525 maintenance_print_architecture (const char *args
, int from_tty
)
527 struct gdbarch
*gdbarch
= get_current_arch ();
530 gdbarch_dump (gdbarch
, gdb_stdout
);
535 if (!file
.open (args
, "w"))
536 perror_with_name (_("maintenance print architecture"));
537 gdbarch_dump (gdbarch
, &file
);
541 /* The "maintenance translate-address" command converts a section and address
542 to a symbol. This can be called in two ways:
543 maintenance translate-address <secname> <addr>
544 or maintenance translate-address <addr>. */
547 maintenance_translate_address (const char *arg
, int from_tty
)
550 struct obj_section
*sect
;
552 struct bound_minimal_symbol sym
;
554 if (arg
== NULL
|| *arg
== 0)
555 error (_("requires argument (address or section + address)"));
561 { /* See if we have a valid section name. */
562 while (*p
&& !isspace (*p
)) /* Find end of section name. */
564 if (*p
== '\000') /* End of command? */
565 error (_("Need to specify section name and address"));
567 int arg_len
= p
- arg
;
568 p
= skip_spaces (p
+ 1);
570 for (objfile
*objfile
: current_program_space
->objfiles ())
571 ALL_OBJFILE_OSECTIONS (objfile
, sect
)
573 if (strncmp (sect
->the_bfd_section
->name
, arg
, arg_len
) == 0)
577 error (_("Unknown section %s."), arg
);
581 address
= parse_and_eval_address (p
);
584 sym
= lookup_minimal_symbol_by_pc_section (address
, sect
);
586 sym
= lookup_minimal_symbol_by_pc (address
);
590 const char *symbol_name
= sym
.minsym
->print_name ();
591 const char *symbol_offset
592 = pulongest (address
- BMSYMBOL_VALUE_ADDRESS (sym
));
594 sect
= sym
.obj_section ();
597 const char *section_name
;
598 const char *obj_name
;
600 gdb_assert (sect
->the_bfd_section
&& sect
->the_bfd_section
->name
);
601 section_name
= sect
->the_bfd_section
->name
;
603 gdb_assert (sect
->objfile
&& objfile_name (sect
->objfile
));
604 obj_name
= objfile_name (sect
->objfile
);
606 if (current_program_space
->multi_objfile_p ())
607 printf_filtered (_("%s + %s in section %s of %s\n"),
608 symbol_name
, symbol_offset
,
609 section_name
, obj_name
);
611 printf_filtered (_("%s + %s in section %s\n"),
612 symbol_name
, symbol_offset
, section_name
);
615 printf_filtered (_("%s + %s\n"), symbol_name
, symbol_offset
);
618 printf_filtered (_("no symbol at %s:%s\n"),
619 sect
->the_bfd_section
->name
, hex_string (address
));
621 printf_filtered (_("no symbol at %s\n"), hex_string (address
));
627 /* When a command is deprecated the user will be warned the first time
628 the command is used. If possible, a replacement will be
632 maintenance_deprecate (const char *args
, int from_tty
)
634 if (args
== NULL
|| *args
== '\0')
636 printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
637 the command you want to deprecate, and optionally the replacement command\n\
638 enclosed in quotes.\n"));
641 maintenance_do_deprecate (args
, 1);
646 maintenance_undeprecate (const char *args
, int from_tty
)
648 if (args
== NULL
|| *args
== '\0')
650 printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
651 the command you want to undeprecate.\n"));
654 maintenance_do_deprecate (args
, 0);
657 /* You really shouldn't be using this. It is just for the testsuite.
658 Rather, you should use deprecate_cmd() when the command is created
659 in _initialize_blah().
661 This function deprecates a command and optionally assigns it a
665 maintenance_do_deprecate (const char *text
, int deprecate
)
667 struct cmd_list_element
*alias
= NULL
;
668 struct cmd_list_element
*prefix_cmd
= NULL
;
669 struct cmd_list_element
*cmd
= NULL
;
671 const char *start_ptr
= NULL
;
672 const char *end_ptr
= NULL
;
674 char *replacement
= NULL
;
679 if (!lookup_cmd_composition (text
, &alias
, &prefix_cmd
, &cmd
))
681 printf_filtered (_("Can't find command '%s' to deprecate.\n"), text
);
687 /* Look for a replacement command. */
688 start_ptr
= strchr (text
, '\"');
689 if (start_ptr
!= NULL
)
692 end_ptr
= strrchr (start_ptr
, '\"');
695 len
= end_ptr
- start_ptr
;
696 replacement
= savestring (start_ptr
, len
);
701 if (!start_ptr
|| !end_ptr
)
705 /* If they used an alias, we only want to deprecate the alias.
707 Note the MALLOCED_REPLACEMENT test. If the command's replacement
708 string was allocated at compile time we don't want to free the
712 if (alias
->malloced_replacement
)
713 xfree ((char *) alias
->replacement
);
717 alias
->deprecated_warn_user
= 1;
718 alias
->cmd_deprecated
= 1;
722 alias
->deprecated_warn_user
= 0;
723 alias
->cmd_deprecated
= 0;
725 alias
->replacement
= replacement
;
726 alias
->malloced_replacement
= 1;
731 if (cmd
->malloced_replacement
)
732 xfree ((char *) cmd
->replacement
);
736 cmd
->deprecated_warn_user
= 1;
737 cmd
->cmd_deprecated
= 1;
741 cmd
->deprecated_warn_user
= 0;
742 cmd
->cmd_deprecated
= 0;
744 cmd
->replacement
= replacement
;
745 cmd
->malloced_replacement
= 1;
751 /* Maintenance set/show framework. */
753 struct cmd_list_element
*maintenance_set_cmdlist
;
754 struct cmd_list_element
*maintenance_show_cmdlist
;
756 /* "maintenance with" command. */
759 maintenance_with_cmd (const char *args
, int from_tty
)
761 with_command_1 ("maintenance set ", maintenance_set_cmdlist
, args
, from_tty
);
764 /* "maintenance with" command completer. */
767 maintenance_with_cmd_completer (struct cmd_list_element
*ignore
,
768 completion_tracker
&tracker
,
769 const char *text
, const char * /*word*/)
771 with_command_completer_1 ("maintenance set ", tracker
, text
);
774 /* Profiling support. */
776 static bool maintenance_profile_p
;
778 show_maintenance_profile_p (struct ui_file
*file
, int from_tty
,
779 struct cmd_list_element
*c
, const char *value
)
781 fprintf_filtered (file
, _("Internal profiling is %s.\n"), value
);
786 #define TEXTEND &_etext
787 #elif defined (HAVE_ETEXT)
789 #define TEXTEND &etext
792 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
794 static int profiling_state
;
796 EXTERN_C
void _mcleanup (void);
799 mcleanup_wrapper (void)
805 EXTERN_C
void monstartup (unsigned long, unsigned long);
809 maintenance_set_profile_cmd (const char *args
, int from_tty
,
810 struct cmd_list_element
*c
)
812 if (maintenance_profile_p
== profiling_state
)
815 profiling_state
= maintenance_profile_p
;
817 if (maintenance_profile_p
)
819 static int profiling_initialized
;
821 if (!profiling_initialized
)
823 atexit (mcleanup_wrapper
);
824 profiling_initialized
= 1;
827 /* "main" is now always the first function in the text segment, so use
828 its address for monstartup. */
829 monstartup ((unsigned long) &main
, (unsigned long) TEXTEND
);
833 extern void _mcleanup (void);
840 maintenance_set_profile_cmd (const char *args
, int from_tty
,
841 struct cmd_list_element
*c
)
843 error (_("Profiling support is not available on this system."));
847 static int n_worker_threads
= -1;
849 /* Update the thread pool for the desired number of threads. */
851 update_thread_pool_size ()
854 int n_threads
= n_worker_threads
;
857 n_threads
= std::thread::hardware_concurrency ();
859 gdb::thread_pool::g_thread_pool
->set_thread_count (n_threads
);
864 maintenance_set_worker_threads (const char *args
, int from_tty
,
865 struct cmd_list_element
*c
)
867 update_thread_pool_size ();
871 /* If true, display time usage both at startup and for each command. */
873 static bool per_command_time
;
875 /* If true, display space usage both at startup and for each command. */
877 static bool per_command_space
;
879 /* If true, display basic symtab stats for each command. */
881 static bool per_command_symtab
;
883 /* mt per-command commands. */
885 static struct cmd_list_element
*per_command_setlist
;
886 static struct cmd_list_element
*per_command_showlist
;
888 /* Set whether to display time statistics to NEW_VALUE
889 (non-zero means true). */
892 set_per_command_time (int new_value
)
894 per_command_time
= new_value
;
897 /* Set whether to display space statistics to NEW_VALUE
898 (non-zero means true). */
901 set_per_command_space (int new_value
)
903 per_command_space
= new_value
;
906 /* Count the number of symtabs and blocks. */
909 count_symtabs_and_blocks (int *nr_symtabs_ptr
, int *nr_compunit_symtabs_ptr
,
913 int nr_compunit_symtabs
= 0;
916 /* When collecting statistics during startup, this is called before
917 pretty much anything in gdb has been initialized, and thus
918 current_program_space may be NULL. */
919 if (current_program_space
!= NULL
)
921 for (objfile
*o
: current_program_space
->objfiles ())
923 for (compunit_symtab
*cu
: o
->compunits ())
925 ++nr_compunit_symtabs
;
926 nr_blocks
+= BLOCKVECTOR_NBLOCKS (COMPUNIT_BLOCKVECTOR (cu
));
927 nr_symtabs
+= std::distance (compunit_filetabs (cu
).begin (),
928 compunit_filetabs (cu
).end ());
933 *nr_symtabs_ptr
= nr_symtabs
;
934 *nr_compunit_symtabs_ptr
= nr_compunit_symtabs
;
935 *nr_blocks_ptr
= nr_blocks
;
938 /* As indicated by display_time and display_space, report GDB's
939 elapsed time and space usage from the base time and space recorded
942 scoped_command_stats::~scoped_command_stats ()
944 /* Early exit if we're not reporting any stats. It can be expensive to
945 compute the pre-command values so don't collect them at all if we're
946 not reporting stats. Alas this doesn't work in the startup case because
947 we don't know yet whether we will be reporting the stats. For the
948 startup case collect the data anyway (it should be cheap at this point),
949 and leave it to the reporter to decide whether to print them. */
952 && !per_command_space
953 && !per_command_symtab
)
956 if (m_time_enabled
&& per_command_time
)
958 print_time (_("command finished"));
960 using namespace std::chrono
;
962 run_time_clock::duration cmd_time
963 = run_time_clock::now () - m_start_cpu_time
;
965 steady_clock::duration wall_time
966 = steady_clock::now () - m_start_wall_time
;
967 /* Subtract time spend in prompt_for_continue from walltime. */
968 wall_time
-= get_prompt_for_continue_wait_time ();
970 printf_unfiltered (!m_msg_type
971 ? _("Startup time: %.6f (cpu), %.6f (wall)\n")
972 : _("Command execution time: %.6f (cpu), %.6f (wall)\n"),
973 duration
<double> (cmd_time
).count (),
974 duration
<double> (wall_time
).count ());
977 if (m_space_enabled
&& per_command_space
)
979 #ifdef HAVE_USEFUL_SBRK
980 char *lim
= (char *) sbrk (0);
982 long space_now
= lim
- lim_at_start
;
983 long space_diff
= space_now
- m_start_space
;
985 printf_unfiltered (!m_msg_type
986 ? _("Space used: %ld (%s%ld during startup)\n")
987 : _("Space used: %ld (%s%ld for this command)\n"),
989 (space_diff
>= 0 ? "+" : ""),
994 if (m_symtab_enabled
&& per_command_symtab
)
996 int nr_symtabs
, nr_compunit_symtabs
, nr_blocks
;
998 count_symtabs_and_blocks (&nr_symtabs
, &nr_compunit_symtabs
, &nr_blocks
);
999 printf_unfiltered (_("#symtabs: %d (+%d),"
1000 " #compunits: %d (+%d),"
1001 " #blocks: %d (+%d)\n"),
1003 nr_symtabs
- m_start_nr_symtabs
,
1004 nr_compunit_symtabs
,
1005 (nr_compunit_symtabs
1006 - m_start_nr_compunit_symtabs
),
1008 nr_blocks
- m_start_nr_blocks
);
1012 scoped_command_stats::scoped_command_stats (bool msg_type
)
1013 : m_msg_type (msg_type
)
1015 if (!m_msg_type
|| per_command_space
)
1017 #ifdef HAVE_USEFUL_SBRK
1018 char *lim
= (char *) sbrk (0);
1019 m_start_space
= lim
- lim_at_start
;
1020 m_space_enabled
= 1;
1024 m_space_enabled
= 0;
1026 if (msg_type
== 0 || per_command_time
)
1028 using namespace std::chrono
;
1030 m_start_cpu_time
= run_time_clock::now ();
1031 m_start_wall_time
= steady_clock::now ();
1034 if (per_command_time
)
1035 print_time (_("command started"));
1040 if (msg_type
== 0 || per_command_symtab
)
1042 int nr_symtabs
, nr_compunit_symtabs
, nr_blocks
;
1044 count_symtabs_and_blocks (&nr_symtabs
, &nr_compunit_symtabs
, &nr_blocks
);
1045 m_start_nr_symtabs
= nr_symtabs
;
1046 m_start_nr_compunit_symtabs
= nr_compunit_symtabs
;
1047 m_start_nr_blocks
= nr_blocks
;
1048 m_symtab_enabled
= 1;
1051 m_symtab_enabled
= 0;
1053 /* Initialize timer to keep track of how long we waited for the user. */
1054 reset_prompt_for_continue_wait_time ();
1060 scoped_command_stats::print_time (const char *msg
)
1062 using namespace std::chrono
;
1064 auto now
= system_clock::now ();
1065 auto ticks
= now
.time_since_epoch ().count () / (1000 * 1000);
1066 auto millis
= ticks
% 1000;
1068 std::time_t as_time
= system_clock::to_time_t (now
);
1070 localtime_r (&as_time
, &tm
);
1073 strftime (out
, sizeof (out
), "%F %H:%M:%S", &tm
);
1075 printf_unfiltered ("%s.%03d - %s\n", out
, (int) millis
, msg
);
1078 /* Handle unknown "mt set per-command" arguments.
1079 In this case have "mt set per-command on|off" affect every setting. */
1082 set_per_command_cmd (const char *args
, int from_tty
)
1084 struct cmd_list_element
*list
;
1087 val
= parse_cli_boolean_value (args
);
1089 error (_("Bad value for 'mt set per-command no'."));
1091 for (list
= per_command_setlist
; list
!= NULL
; list
= list
->next
)
1092 if (list
->var_type
== var_boolean
)
1094 gdb_assert (list
->type
== set_cmd
);
1095 do_set_command (args
, from_tty
, list
);
1101 /* The "maintenance selftest" command. */
1104 maintenance_selftest (const char *args
, int from_tty
)
1107 gdb_argv
argv (args
);
1108 selftests::run_tests (argv
.as_array_view ());
1110 printf_filtered (_("\
1111 Selftests have been disabled for this build.\n"));
1116 maintenance_info_selftests (const char *arg
, int from_tty
)
1119 printf_filtered ("Registered selftests:\n");
1120 selftests::for_each_selftest ([] (const std::string
&name
) {
1121 printf_filtered (" - %s\n", name
.c_str ());
1124 printf_filtered (_("\
1125 Selftests have been disabled for this build.\n"));
1130 void _initialize_maint_cmds ();
1132 _initialize_maint_cmds ()
1134 struct cmd_list_element
*cmd
;
1136 add_basic_prefix_cmd ("maintenance", class_maintenance
, _("\
1137 Commands for use by GDB maintainers.\n\
1138 Includes commands to dump specific internal GDB structures in\n\
1139 a human readable form, to cause GDB to deliberately dump core, etc."),
1140 &maintenancelist
, "maintenance ", 0,
1143 add_com_alias ("mt", "maintenance", class_maintenance
, 1);
1145 add_basic_prefix_cmd ("info", class_maintenance
, _("\
1146 Commands for showing internal info about the program being debugged."),
1147 &maintenanceinfolist
, "maintenance info ", 0,
1149 add_alias_cmd ("i", "info", class_maintenance
, 1, &maintenancelist
);
1151 const auto opts
= make_maint_info_sections_options_def_group (nullptr);
1152 static std::string maint_info_sections_command_help
1153 = gdb::option::build_help (_("\
1154 List the BFD sections of the exec and core files.\n\
1156 Usage: maintenance info sections [-all-objects] [FILTERS]\n\
1158 FILTERS is a list of words, each word is either:\n\
1159 + A section name - any section with this name will be printed, or\n\
1160 + A section flag - any section with this flag will be printed. The\n\
1162 ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
1163 HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
1165 Sections matching any of the FILTERS will be listed (no FILTERS implies\n\
1166 all sections should be printed).\n\
1170 cmd
= add_cmd ("sections", class_maintenance
, maintenance_info_sections
,
1171 maint_info_sections_command_help
.c_str (),
1172 &maintenanceinfolist
);
1173 set_cmd_completer_handle_brkchars (cmd
, maint_info_sections_completer
);
1175 add_cmd ("target-sections", class_maintenance
,
1176 maintenance_info_target_sections
, _("\
1177 List GDB's internal section table.\n\
1179 Print the current targets section list. This is a sub-set of all\n\
1180 sections, from all objects currently loaded. Usually the ALLOC\n\
1182 &maintenanceinfolist
);
1184 add_basic_prefix_cmd ("print", class_maintenance
,
1185 _("Maintenance command for printing GDB internal state."),
1186 &maintenanceprintlist
, "maintenance print ", 0,
1189 add_basic_prefix_cmd ("flush", class_maintenance
,
1190 _("Maintenance command for flushing GDB internal caches."),
1191 &maintenanceflushlist
, "maintenance flush ", 0,
1194 add_basic_prefix_cmd ("set", class_maintenance
, _("\
1195 Set GDB internal variables used by the GDB maintainer.\n\
1196 Configure variables internal to GDB that aid in GDB's maintenance"),
1197 &maintenance_set_cmdlist
, "maintenance set ",
1201 add_show_prefix_cmd ("show", class_maintenance
, _("\
1202 Show GDB internal variables used by the GDB maintainer.\n\
1203 Configure variables internal to GDB that aid in GDB's maintenance"),
1204 &maintenance_show_cmdlist
, "maintenance show ",
1208 cmd
= add_cmd ("with", class_maintenance
, maintenance_with_cmd
, _("\
1209 Like \"with\", but works with \"maintenance set\" variables.\n\
1210 Usage: maintenance with SETTING [VALUE] [-- COMMAND]\n\
1211 With no COMMAND, repeats the last executed command.\n\
1212 SETTING is any setting you can change with the \"maintenance set\"\n\
1215 set_cmd_completer_handle_brkchars (cmd
, maintenance_with_cmd_completer
);
1218 add_cmd ("dump-me", class_maintenance
, maintenance_dump_me
, _("\
1219 Get fatal error; make debugger dump its core.\n\
1220 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
1221 itself a SIGQUIT signal."),
1225 add_cmd ("internal-error", class_maintenance
,
1226 maintenance_internal_error
, _("\
1227 Give GDB an internal error.\n\
1228 Cause GDB to behave as if an internal error was detected."),
1231 add_cmd ("internal-warning", class_maintenance
,
1232 maintenance_internal_warning
, _("\
1233 Give GDB an internal warning.\n\
1234 Cause GDB to behave as if an internal warning was reported."),
1237 add_cmd ("demangler-warning", class_maintenance
,
1238 maintenance_demangler_warning
, _("\
1239 Give GDB a demangler warning.\n\
1240 Cause GDB to behave as if a demangler warning was reported."),
1243 cmd
= add_cmd ("demangle", class_maintenance
, maintenance_demangle
, _("\
1244 This command has been moved to \"demangle\"."),
1246 deprecate_cmd (cmd
, "demangle");
1248 add_prefix_cmd ("per-command", class_maintenance
, set_per_command_cmd
, _("\
1249 Per-command statistics settings."),
1250 &per_command_setlist
, "maintenance set per-command ",
1251 1/*allow-unknown*/, &maintenance_set_cmdlist
);
1253 add_show_prefix_cmd ("per-command", class_maintenance
, _("\
1254 Show per-command statistics settings."),
1255 &per_command_showlist
, "maintenance show per-command ",
1256 0/*allow-unknown*/, &maintenance_show_cmdlist
);
1258 add_setshow_boolean_cmd ("time", class_maintenance
,
1259 &per_command_time
, _("\
1260 Set whether to display per-command execution time."), _("\
1261 Show whether to display per-command execution time."),
1263 If enabled, the execution time for each command will be\n\
1264 displayed following the command's output."),
1266 &per_command_setlist
, &per_command_showlist
);
1268 add_setshow_boolean_cmd ("space", class_maintenance
,
1269 &per_command_space
, _("\
1270 Set whether to display per-command space usage."), _("\
1271 Show whether to display per-command space usage."),
1273 If enabled, the space usage for each command will be\n\
1274 displayed following the command's output."),
1276 &per_command_setlist
, &per_command_showlist
);
1278 add_setshow_boolean_cmd ("symtab", class_maintenance
,
1279 &per_command_symtab
, _("\
1280 Set whether to display per-command symtab statistics."), _("\
1281 Show whether to display per-command symtab statistics."),
1283 If enabled, the basic symtab statistics for each command will be\n\
1284 displayed following the command's output."),
1286 &per_command_setlist
, &per_command_showlist
);
1288 /* This is equivalent to "mt set per-command time on".
1289 Kept because some people are used to typing "mt time 1". */
1290 add_cmd ("time", class_maintenance
, maintenance_time_display
, _("\
1291 Set the display of time usage.\n\
1292 If nonzero, will cause the execution time for each command to be\n\
1293 displayed, following the command's output."),
1296 /* This is equivalent to "mt set per-command space on".
1297 Kept because some people are used to typing "mt space 1". */
1298 add_cmd ("space", class_maintenance
, maintenance_space_display
, _("\
1299 Set the display of space usage.\n\
1300 If nonzero, will cause the execution space for each command to be\n\
1301 displayed, following the command's output."),
1304 cmd
= add_cmd ("type", class_maintenance
, maintenance_print_type
, _("\
1305 Print a type chain for a given symbol.\n\
1306 For each node in a type chain, print the raw data for each member of\n\
1307 the type structure, and the interpretation of the data."),
1308 &maintenanceprintlist
);
1309 set_cmd_completer (cmd
, expression_completer
);
1311 add_cmd ("statistics", class_maintenance
, maintenance_print_statistics
,
1312 _("Print statistics about internal gdb state."),
1313 &maintenanceprintlist
);
1315 add_cmd ("architecture", class_maintenance
,
1316 maintenance_print_architecture
, _("\
1317 Print the internal architecture configuration.\n\
1318 Takes an optional file parameter."),
1319 &maintenanceprintlist
);
1321 add_basic_prefix_cmd ("check", class_maintenance
, _("\
1322 Commands for checking internal gdb state."),
1323 &maintenancechecklist
, "maintenance check ", 0,
1326 add_cmd ("translate-address", class_maintenance
,
1327 maintenance_translate_address
,
1328 _("Translate a section name and address to a symbol."),
1331 add_cmd ("deprecate", class_maintenance
, maintenance_deprecate
, _("\
1332 Deprecate a command (for testing purposes).\n\
1333 Usage: maintenance deprecate COMMANDNAME [\"REPLACEMENT\"]\n\
1334 This is used by the testsuite to check the command deprecator.\n\
1335 You probably shouldn't use this,\n\
1336 rather you should use the C function deprecate_cmd()."), &maintenancelist
);
1338 add_cmd ("undeprecate", class_maintenance
, maintenance_undeprecate
, _("\
1339 Undeprecate a command (for testing purposes).\n\
1340 Usage: maintenance undeprecate COMMANDNAME\n\
1341 This is used by the testsuite to check the command deprecator.\n\
1342 You probably shouldn't use this."),
1345 add_cmd ("selftest", class_maintenance
, maintenance_selftest
, _("\
1346 Run gdb's unit tests.\n\
1347 Usage: maintenance selftest [FILTER]\n\
1348 This will run any unit tests that were built in to gdb.\n\
1349 If a filter is given, only the tests with that value in their name will ran."),
1352 add_cmd ("selftests", class_maintenance
, maintenance_info_selftests
,
1353 _("List the registered selftests."), &maintenanceinfolist
);
1355 add_setshow_boolean_cmd ("profile", class_maintenance
,
1356 &maintenance_profile_p
, _("\
1357 Set internal profiling."), _("\
1358 Show internal profiling."), _("\
1359 When enabled GDB is profiled."),
1360 maintenance_set_profile_cmd
,
1361 show_maintenance_profile_p
,
1362 &maintenance_set_cmdlist
,
1363 &maintenance_show_cmdlist
);
1365 add_setshow_zuinteger_unlimited_cmd ("worker-threads",
1367 &n_worker_threads
, _("\
1368 Set the number of worker threads GDB can use."), _("\
1369 Show the number of worker threads GDB can use."), _("\
1370 GDB may use multiple threads to speed up certain CPU-intensive operations,\n\
1371 such as demangling symbol names."),
1372 maintenance_set_worker_threads
, NULL
,
1373 &maintenance_set_cmdlist
,
1374 &maintenance_show_cmdlist
);
1376 update_thread_pool_size ();