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"
44 #include "cli/cli-decode.h"
45 #include "cli/cli-utils.h"
46 #include "cli/cli-setshow.h"
47 #include "cli/cli-cmds.h"
50 #include "gdbsupport/thread-pool.h"
53 static void maintenance_do_deprecate (const char *, int);
57 maintenance_dump_me (const char *args
, int from_tty
)
59 if (query (_("Should GDB dump core? ")))
62 /* SIGQUIT by default is ignored, so use SIGABRT instead. */
63 signal (SIGABRT
, SIG_DFL
);
64 kill (getpid (), SIGABRT
);
66 signal (SIGQUIT
, SIG_DFL
);
67 kill (getpid (), SIGQUIT
);
73 /* Stimulate the internal error mechanism that GDB uses when an
74 internal problem is detected. Allows testing of the mechanism.
75 Also useful when the user wants to drop a core file but not exit
79 maintenance_internal_error (const char *args
, int from_tty
)
81 internal_error (__FILE__
, __LINE__
, "%s", (args
== NULL
? "" : args
));
84 /* Stimulate the internal error mechanism that GDB uses when an
85 internal problem is detected. Allows testing of the mechanism.
86 Also useful when the user wants to drop a core file but not exit
90 maintenance_internal_warning (const char *args
, int from_tty
)
92 internal_warning (__FILE__
, __LINE__
, "%s", (args
== NULL
? "" : args
));
95 /* Stimulate the internal error mechanism that GDB uses when an
96 demangler problem is detected. Allows testing of the mechanism. */
99 maintenance_demangler_warning (const char *args
, int from_tty
)
101 demangler_warning (__FILE__
, __LINE__
, "%s", (args
== NULL
? "" : args
));
104 /* Old command to demangle a string. The command has been moved to "demangle".
105 It is kept for now because otherwise "mt demangle" gets interpreted as
106 "mt demangler-warning" which artificially creates an internal gdb error. */
109 maintenance_demangle (const char *args
, int from_tty
)
111 printf_filtered (_("This command has been moved to \"demangle\".\n"));
115 maintenance_time_display (const char *args
, int from_tty
)
117 if (args
== NULL
|| *args
== '\0')
118 printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
120 set_per_command_time (strtol (args
, NULL
, 10));
124 maintenance_space_display (const char *args
, int from_tty
)
126 if (args
== NULL
|| *args
== '\0')
127 printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
129 set_per_command_space (strtol (args
, NULL
, 10));
132 /* Mini tokenizing lexer for 'maint info sections' command. */
135 match_substring (const char *string
, const char *substr
)
137 int substr_len
= strlen (substr
);
140 while ((tok
= strstr (string
, substr
)) != NULL
)
142 /* Got a partial match. Is it a whole word? */
147 /* Token is delimited at the front... */
148 if (tok
[substr_len
] == ' '
149 || tok
[substr_len
] == '\t'
150 || tok
[substr_len
] == '\0')
152 /* Token is delimited at the rear. Got a whole-word match. */
156 /* Token didn't match as a whole word. Advance and try again. */
162 /* Structure holding information about a single bfd section flag. This is
163 used by the "maintenance info sections" command to print the sections,
164 and for filtering which sections are printed. */
166 struct single_bfd_flag_info
168 /* The name of the section. This is what is printed for the flag, and
169 what the user enter in order to filter by flag. */
172 /* The bfd defined SEC_* flagword value for this flag. */
176 /* Vector of all the known bfd flags. */
178 static const single_bfd_flag_info bfd_flag_info
[] =
180 { "ALLOC", SEC_ALLOC
},
181 { "LOAD", SEC_LOAD
},
182 { "RELOC", SEC_RELOC
},
183 { "READONLY", SEC_READONLY
},
184 { "CODE", SEC_CODE
},
185 { "DATA", SEC_DATA
},
187 { "CONSTRUCTOR", SEC_CONSTRUCTOR
},
188 { "HAS_CONTENTS", SEC_HAS_CONTENTS
},
189 { "NEVER_LOAD", SEC_NEVER_LOAD
},
190 { "COFF_SHARED_LIBRARY", SEC_COFF_SHARED_LIBRARY
},
191 { "IS_COMMON", SEC_IS_COMMON
}
194 /* For each flag in the global BFD_FLAG_INFO list, if FLAGS has a flag's
195 flagword value set, and STRING contains the flag's name then return
196 true, otherwise return false. STRING is never nullptr. */
199 match_bfd_flags (const char *string
, flagword flags
)
201 gdb_assert (string
!= nullptr);
203 for (const auto &f
: bfd_flag_info
)
206 && match_substring (string
, f
.name
))
213 /* Print the names of all flags set in FLAGS. The names are taken from the
214 BFD_FLAG_INFO global. */
217 print_bfd_flags (flagword flags
)
219 for (const auto &f
: bfd_flag_info
)
222 printf_filtered (" %s", f
.name
);
227 maint_print_section_info (const char *name
, flagword flags
,
228 CORE_ADDR addr
, CORE_ADDR endaddr
,
229 unsigned long filepos
, int addr_size
)
231 printf_filtered (" %s", hex_string_custom (addr
, addr_size
));
232 printf_filtered ("->%s", hex_string_custom (endaddr
, addr_size
));
233 printf_filtered (" at %s",
234 hex_string_custom ((unsigned long) filepos
, 8));
235 printf_filtered (": %s", name
);
236 print_bfd_flags (flags
);
237 printf_filtered ("\n");
240 /* Return the number of digits required to display COUNT in decimal.
242 Used when pretty printing index numbers to ensure all of the indexes line
246 index_digits (int count
)
248 return ((int) log10 ((float) count
)) + 1;
251 /* Helper function to pretty-print the section index of ASECT from ABFD.
252 The INDEX_DIGITS is the number of digits in the largest index that will
253 be printed, and is used to pretty-print the resulting string. */
256 print_section_index (bfd
*abfd
,
261 = string_printf (" [%d] ", gdb_bfd_section_index (abfd
, asect
));
262 /* The '+ 4' for the leading and trailing characters. */
263 printf_filtered ("%-*s", (index_digits
+ 4), result
.c_str ());
266 /* Print information about ASECT from ABFD. The section will be printed using
267 the VMA's from the bfd, which will not be the relocated addresses for bfds
268 that should be relocated. The information must be printed with the same
269 layout as PRINT_OBJFILE_SECTION_INFO below.
271 ARG is the argument string passed by the user to the top level maintenance
272 info sections command. Used for filtering which sections are printed. */
275 print_bfd_section_info (bfd
*abfd
, asection
*asect
, const char *arg
,
278 flagword flags
= bfd_section_flags (asect
);
279 const char *name
= bfd_section_name (asect
);
281 if (arg
== NULL
|| *arg
== '\0'
282 || match_substring (arg
, name
)
283 || match_bfd_flags (arg
, flags
))
285 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
286 int addr_size
= gdbarch_addr_bit (gdbarch
) / 8;
287 CORE_ADDR addr
, endaddr
;
289 addr
= bfd_section_vma (asect
);
290 endaddr
= addr
+ bfd_section_size (asect
);
291 print_section_index (abfd
, asect
, index_digits
);
292 maint_print_section_info (name
, flags
, addr
, endaddr
,
293 asect
->filepos
, addr_size
);
297 /* Print information about ASECT which is GDB's wrapper around a section
298 from ABFD. The information must be printed with the same layout as
299 PRINT_BFD_SECTION_INFO above. PRINT_DATA holds information used to
300 filter which sections are printed, and for formatting the output.
302 ARG is the argument string passed by the user to the top level maintenance
303 info sections command. Used for filtering which sections are printed. */
306 print_objfile_section_info (bfd
*abfd
, struct obj_section
*asect
,
307 const char *arg
, int index_digits
)
309 flagword flags
= bfd_section_flags (asect
->the_bfd_section
);
310 const char *name
= bfd_section_name (asect
->the_bfd_section
);
312 if (arg
== NULL
|| *arg
== '\0'
313 || match_substring (arg
, name
)
314 || match_bfd_flags (arg
, flags
))
316 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
317 int addr_size
= gdbarch_addr_bit (gdbarch
) / 8;
319 print_section_index (abfd
, asect
->the_bfd_section
, index_digits
);
320 maint_print_section_info (name
, flags
,
321 obj_section_addr (asect
),
322 obj_section_endaddr (asect
),
323 asect
->the_bfd_section
->filepos
,
328 /* Find an obj_section, GDB's wrapper around a bfd section for ASECTION
329 from ABFD. It might be that no such wrapper exists (for example debug
330 sections don't have such wrappers) in which case nullptr is returned. */
333 maint_obj_section_from_bfd_section (bfd
*abfd
,
337 if (ofile
->sections
== nullptr)
341 = &ofile
->sections
[gdb_bfd_section_index (abfd
, asection
)];
343 if (osect
>= ofile
->sections_end
)
349 /* Print information about all sections from ABFD, which is the bfd
350 corresponding to OBJFILE. It is fine for OBJFILE to be nullptr, but
351 ABFD must never be nullptr. If OBJFILE is provided then the sections of
352 ABFD will (potentially) be displayed relocated (i.e. the object file was
353 loaded with add-symbol-file and custom offsets were provided).
355 HEADER is a string that describes this file, e.g. 'Exec file: ', or
358 ARG is a string used for filtering which sections are printed, this can
359 be nullptr for no filtering. See the top level 'maint info sections'
360 for a fuller description of the possible filtering strings. */
363 maint_print_all_sections (const char *header
, bfd
*abfd
, objfile
*objfile
,
366 puts_filtered (header
);
368 printf_filtered ("`%s', ", bfd_get_filename (abfd
));
370 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
372 int section_count
= gdb_bfd_count_sections (abfd
);
373 int digits
= index_digits (section_count
);
375 for (asection
*sect
: gdb_bfd_sections (abfd
))
377 obj_section
*osect
= nullptr;
379 if (objfile
!= nullptr)
381 gdb_assert (objfile
->sections
!= nullptr);
383 = maint_obj_section_from_bfd_section (abfd
, sect
, objfile
);
384 if (osect
->the_bfd_section
== nullptr)
388 if (osect
== nullptr)
389 print_bfd_section_info (abfd
, sect
, arg
, digits
);
391 print_objfile_section_info (abfd
, osect
, arg
, digits
);
395 /* The options for the "maintenance info sections" command. */
397 struct maint_info_sections_opts
399 /* For "-all-objects". */
400 bool all_objects
= false;
403 static const gdb::option::option_def maint_info_sections_option_defs
[] = {
405 gdb::option::flag_option_def
<maint_info_sections_opts
> {
407 [] (maint_info_sections_opts
*opts
) { return &opts
->all_objects
; },
408 N_("Display information from all loaded object files."),
412 /* Create an option_def_group for the "maintenance info sections" options,
413 with CC_OPTS as context. */
415 static inline gdb::option::option_def_group
416 make_maint_info_sections_options_def_group (maint_info_sections_opts
*cc_opts
)
418 return {{maint_info_sections_option_defs
}, cc_opts
};
421 /* Completion for the "maintenance info sections" command. */
424 maint_info_sections_completer (struct cmd_list_element
*cmd
,
425 completion_tracker
&tracker
,
426 const char *text
, const char * /* word */)
428 /* Complete command options. */
429 const auto group
= make_maint_info_sections_options_def_group (nullptr);
430 if (gdb::option::complete_options
431 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
433 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
435 /* Offer completion for section flags, but not section names. This is
436 only a maintenance command after all, no point going over the top. */
437 std::vector
<const char *> flags
;
438 for (const auto &f
: bfd_flag_info
)
439 flags
.push_back (f
.name
);
440 flags
.push_back (nullptr);
441 complete_on_enum (tracker
, flags
.data (), text
, word
);
444 /* Implement the "maintenance info sections" command. */
447 maintenance_info_sections (const char *arg
, int from_tty
)
449 /* Check if the "-all-objects" flag was passed. */
450 maint_info_sections_opts opts
;
451 const auto group
= make_maint_info_sections_options_def_group (&opts
);
452 gdb::option::process_options
453 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
455 for (objfile
*ofile
: current_program_space
->objfiles ())
457 if (ofile
->obfd
== current_program_space
->exec_bfd ())
458 maint_print_all_sections (_("Exec file: "), ofile
->obfd
, ofile
, arg
);
459 else if (opts
.all_objects
)
460 maint_print_all_sections (_("Object file: "), ofile
->obfd
, ofile
, arg
);
464 maint_print_all_sections (_("Core file: "), core_bfd
, nullptr, arg
);
468 maintenance_print_statistics (const char *args
, int from_tty
)
470 print_objfile_statistics ();
471 print_symbol_bcache_statistics ();
475 maintenance_print_architecture (const char *args
, int from_tty
)
477 struct gdbarch
*gdbarch
= get_current_arch ();
480 gdbarch_dump (gdbarch
, gdb_stdout
);
485 if (!file
.open (args
, "w"))
486 perror_with_name (_("maintenance print architecture"));
487 gdbarch_dump (gdbarch
, &file
);
491 /* The "maintenance translate-address" command converts a section and address
492 to a symbol. This can be called in two ways:
493 maintenance translate-address <secname> <addr>
494 or maintenance translate-address <addr>. */
497 maintenance_translate_address (const char *arg
, int from_tty
)
500 struct obj_section
*sect
;
502 struct bound_minimal_symbol sym
;
504 if (arg
== NULL
|| *arg
== 0)
505 error (_("requires argument (address or section + address)"));
511 { /* See if we have a valid section name. */
512 while (*p
&& !isspace (*p
)) /* Find end of section name. */
514 if (*p
== '\000') /* End of command? */
515 error (_("Need to specify section name and address"));
517 int arg_len
= p
- arg
;
518 p
= skip_spaces (p
+ 1);
520 for (objfile
*objfile
: current_program_space
->objfiles ())
521 ALL_OBJFILE_OSECTIONS (objfile
, sect
)
523 if (strncmp (sect
->the_bfd_section
->name
, arg
, arg_len
) == 0)
527 error (_("Unknown section %s."), arg
);
531 address
= parse_and_eval_address (p
);
534 sym
= lookup_minimal_symbol_by_pc_section (address
, sect
);
536 sym
= lookup_minimal_symbol_by_pc (address
);
540 const char *symbol_name
= sym
.minsym
->print_name ();
541 const char *symbol_offset
542 = pulongest (address
- BMSYMBOL_VALUE_ADDRESS (sym
));
544 sect
= sym
.obj_section ();
547 const char *section_name
;
548 const char *obj_name
;
550 gdb_assert (sect
->the_bfd_section
&& sect
->the_bfd_section
->name
);
551 section_name
= sect
->the_bfd_section
->name
;
553 gdb_assert (sect
->objfile
&& objfile_name (sect
->objfile
));
554 obj_name
= objfile_name (sect
->objfile
);
556 if (current_program_space
->multi_objfile_p ())
557 printf_filtered (_("%s + %s in section %s of %s\n"),
558 symbol_name
, symbol_offset
,
559 section_name
, obj_name
);
561 printf_filtered (_("%s + %s in section %s\n"),
562 symbol_name
, symbol_offset
, section_name
);
565 printf_filtered (_("%s + %s\n"), symbol_name
, symbol_offset
);
568 printf_filtered (_("no symbol at %s:%s\n"),
569 sect
->the_bfd_section
->name
, hex_string (address
));
571 printf_filtered (_("no symbol at %s\n"), hex_string (address
));
577 /* When a command is deprecated the user will be warned the first time
578 the command is used. If possible, a replacement will be
582 maintenance_deprecate (const char *args
, int from_tty
)
584 if (args
== NULL
|| *args
== '\0')
586 printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
587 the command you want to deprecate, and optionally the replacement command\n\
588 enclosed in quotes.\n"));
591 maintenance_do_deprecate (args
, 1);
596 maintenance_undeprecate (const char *args
, int from_tty
)
598 if (args
== NULL
|| *args
== '\0')
600 printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
601 the command you want to undeprecate.\n"));
604 maintenance_do_deprecate (args
, 0);
607 /* You really shouldn't be using this. It is just for the testsuite.
608 Rather, you should use deprecate_cmd() when the command is created
609 in _initialize_blah().
611 This function deprecates a command and optionally assigns it a
615 maintenance_do_deprecate (const char *text
, int deprecate
)
617 struct cmd_list_element
*alias
= NULL
;
618 struct cmd_list_element
*prefix_cmd
= NULL
;
619 struct cmd_list_element
*cmd
= NULL
;
621 const char *start_ptr
= NULL
;
622 const char *end_ptr
= NULL
;
624 char *replacement
= NULL
;
629 if (!lookup_cmd_composition (text
, &alias
, &prefix_cmd
, &cmd
))
631 printf_filtered (_("Can't find command '%s' to deprecate.\n"), text
);
637 /* Look for a replacement command. */
638 start_ptr
= strchr (text
, '\"');
639 if (start_ptr
!= NULL
)
642 end_ptr
= strrchr (start_ptr
, '\"');
645 len
= end_ptr
- start_ptr
;
646 replacement
= savestring (start_ptr
, len
);
651 if (!start_ptr
|| !end_ptr
)
655 /* If they used an alias, we only want to deprecate the alias.
657 Note the MALLOCED_REPLACEMENT test. If the command's replacement
658 string was allocated at compile time we don't want to free the
662 if (alias
->malloced_replacement
)
663 xfree ((char *) alias
->replacement
);
667 alias
->deprecated_warn_user
= 1;
668 alias
->cmd_deprecated
= 1;
672 alias
->deprecated_warn_user
= 0;
673 alias
->cmd_deprecated
= 0;
675 alias
->replacement
= replacement
;
676 alias
->malloced_replacement
= 1;
681 if (cmd
->malloced_replacement
)
682 xfree ((char *) cmd
->replacement
);
686 cmd
->deprecated_warn_user
= 1;
687 cmd
->cmd_deprecated
= 1;
691 cmd
->deprecated_warn_user
= 0;
692 cmd
->cmd_deprecated
= 0;
694 cmd
->replacement
= replacement
;
695 cmd
->malloced_replacement
= 1;
701 /* Maintenance set/show framework. */
703 struct cmd_list_element
*maintenance_set_cmdlist
;
704 struct cmd_list_element
*maintenance_show_cmdlist
;
706 /* "maintenance with" command. */
709 maintenance_with_cmd (const char *args
, int from_tty
)
711 with_command_1 ("maintenance set ", maintenance_set_cmdlist
, args
, from_tty
);
714 /* "maintenance with" command completer. */
717 maintenance_with_cmd_completer (struct cmd_list_element
*ignore
,
718 completion_tracker
&tracker
,
719 const char *text
, const char * /*word*/)
721 with_command_completer_1 ("maintenance set ", tracker
, text
);
724 /* Profiling support. */
726 static bool maintenance_profile_p
;
728 show_maintenance_profile_p (struct ui_file
*file
, int from_tty
,
729 struct cmd_list_element
*c
, const char *value
)
731 fprintf_filtered (file
, _("Internal profiling is %s.\n"), value
);
736 #define TEXTEND &_etext
737 #elif defined (HAVE_ETEXT)
739 #define TEXTEND &etext
742 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
744 static int profiling_state
;
746 EXTERN_C
void _mcleanup (void);
749 mcleanup_wrapper (void)
755 EXTERN_C
void monstartup (unsigned long, unsigned long);
759 maintenance_set_profile_cmd (const char *args
, int from_tty
,
760 struct cmd_list_element
*c
)
762 if (maintenance_profile_p
== profiling_state
)
765 profiling_state
= maintenance_profile_p
;
767 if (maintenance_profile_p
)
769 static int profiling_initialized
;
771 if (!profiling_initialized
)
773 atexit (mcleanup_wrapper
);
774 profiling_initialized
= 1;
777 /* "main" is now always the first function in the text segment, so use
778 its address for monstartup. */
779 monstartup ((unsigned long) &main
, (unsigned long) TEXTEND
);
783 extern void _mcleanup (void);
790 maintenance_set_profile_cmd (const char *args
, int from_tty
,
791 struct cmd_list_element
*c
)
793 error (_("Profiling support is not available on this system."));
797 static int n_worker_threads
= -1;
799 /* Update the thread pool for the desired number of threads. */
801 update_thread_pool_size ()
804 int n_threads
= n_worker_threads
;
807 n_threads
= std::thread::hardware_concurrency ();
809 gdb::thread_pool::g_thread_pool
->set_thread_count (n_threads
);
814 maintenance_set_worker_threads (const char *args
, int from_tty
,
815 struct cmd_list_element
*c
)
817 update_thread_pool_size ();
821 /* If true, display time usage both at startup and for each command. */
823 static bool per_command_time
;
825 /* If true, display space usage both at startup and for each command. */
827 static bool per_command_space
;
829 /* If true, display basic symtab stats for each command. */
831 static bool per_command_symtab
;
833 /* mt per-command commands. */
835 static struct cmd_list_element
*per_command_setlist
;
836 static struct cmd_list_element
*per_command_showlist
;
838 /* Set whether to display time statistics to NEW_VALUE
839 (non-zero means true). */
842 set_per_command_time (int new_value
)
844 per_command_time
= new_value
;
847 /* Set whether to display space statistics to NEW_VALUE
848 (non-zero means true). */
851 set_per_command_space (int new_value
)
853 per_command_space
= new_value
;
856 /* Count the number of symtabs and blocks. */
859 count_symtabs_and_blocks (int *nr_symtabs_ptr
, int *nr_compunit_symtabs_ptr
,
863 int nr_compunit_symtabs
= 0;
866 /* When collecting statistics during startup, this is called before
867 pretty much anything in gdb has been initialized, and thus
868 current_program_space may be NULL. */
869 if (current_program_space
!= NULL
)
871 for (objfile
*o
: current_program_space
->objfiles ())
873 for (compunit_symtab
*cu
: o
->compunits ())
875 ++nr_compunit_symtabs
;
876 nr_blocks
+= BLOCKVECTOR_NBLOCKS (COMPUNIT_BLOCKVECTOR (cu
));
877 nr_symtabs
+= std::distance (compunit_filetabs (cu
).begin (),
878 compunit_filetabs (cu
).end ());
883 *nr_symtabs_ptr
= nr_symtabs
;
884 *nr_compunit_symtabs_ptr
= nr_compunit_symtabs
;
885 *nr_blocks_ptr
= nr_blocks
;
888 /* As indicated by display_time and display_space, report GDB's
889 elapsed time and space usage from the base time and space recorded
892 scoped_command_stats::~scoped_command_stats ()
894 /* Early exit if we're not reporting any stats. It can be expensive to
895 compute the pre-command values so don't collect them at all if we're
896 not reporting stats. Alas this doesn't work in the startup case because
897 we don't know yet whether we will be reporting the stats. For the
898 startup case collect the data anyway (it should be cheap at this point),
899 and leave it to the reporter to decide whether to print them. */
902 && !per_command_space
903 && !per_command_symtab
)
906 if (m_time_enabled
&& per_command_time
)
908 print_time (_("command finished"));
910 using namespace std::chrono
;
912 run_time_clock::duration cmd_time
913 = run_time_clock::now () - m_start_cpu_time
;
915 steady_clock::duration wall_time
916 = steady_clock::now () - m_start_wall_time
;
917 /* Subtract time spend in prompt_for_continue from walltime. */
918 wall_time
-= get_prompt_for_continue_wait_time ();
920 printf_unfiltered (!m_msg_type
921 ? _("Startup time: %.6f (cpu), %.6f (wall)\n")
922 : _("Command execution time: %.6f (cpu), %.6f (wall)\n"),
923 duration
<double> (cmd_time
).count (),
924 duration
<double> (wall_time
).count ());
927 if (m_space_enabled
&& per_command_space
)
929 #ifdef HAVE_USEFUL_SBRK
930 char *lim
= (char *) sbrk (0);
932 long space_now
= lim
- lim_at_start
;
933 long space_diff
= space_now
- m_start_space
;
935 printf_unfiltered (!m_msg_type
936 ? _("Space used: %ld (%s%ld during startup)\n")
937 : _("Space used: %ld (%s%ld for this command)\n"),
939 (space_diff
>= 0 ? "+" : ""),
944 if (m_symtab_enabled
&& per_command_symtab
)
946 int nr_symtabs
, nr_compunit_symtabs
, nr_blocks
;
948 count_symtabs_and_blocks (&nr_symtabs
, &nr_compunit_symtabs
, &nr_blocks
);
949 printf_unfiltered (_("#symtabs: %d (+%d),"
950 " #compunits: %d (+%d),"
951 " #blocks: %d (+%d)\n"),
953 nr_symtabs
- m_start_nr_symtabs
,
956 - m_start_nr_compunit_symtabs
),
958 nr_blocks
- m_start_nr_blocks
);
962 scoped_command_stats::scoped_command_stats (bool msg_type
)
963 : m_msg_type (msg_type
)
965 if (!m_msg_type
|| per_command_space
)
967 #ifdef HAVE_USEFUL_SBRK
968 char *lim
= (char *) sbrk (0);
969 m_start_space
= lim
- lim_at_start
;
976 if (msg_type
== 0 || per_command_time
)
978 using namespace std::chrono
;
980 m_start_cpu_time
= run_time_clock::now ();
981 m_start_wall_time
= steady_clock::now ();
984 if (per_command_time
)
985 print_time (_("command started"));
990 if (msg_type
== 0 || per_command_symtab
)
992 int nr_symtabs
, nr_compunit_symtabs
, nr_blocks
;
994 count_symtabs_and_blocks (&nr_symtabs
, &nr_compunit_symtabs
, &nr_blocks
);
995 m_start_nr_symtabs
= nr_symtabs
;
996 m_start_nr_compunit_symtabs
= nr_compunit_symtabs
;
997 m_start_nr_blocks
= nr_blocks
;
998 m_symtab_enabled
= 1;
1001 m_symtab_enabled
= 0;
1003 /* Initialize timer to keep track of how long we waited for the user. */
1004 reset_prompt_for_continue_wait_time ();
1010 scoped_command_stats::print_time (const char *msg
)
1012 using namespace std::chrono
;
1014 auto now
= system_clock::now ();
1015 auto ticks
= now
.time_since_epoch ().count () / (1000 * 1000);
1016 auto millis
= ticks
% 1000;
1018 std::time_t as_time
= system_clock::to_time_t (now
);
1020 localtime_r (&as_time
, &tm
);
1023 strftime (out
, sizeof (out
), "%F %H:%M:%S", &tm
);
1025 printf_unfiltered ("%s.%03d - %s\n", out
, (int) millis
, msg
);
1028 /* Handle unknown "mt set per-command" arguments.
1029 In this case have "mt set per-command on|off" affect every setting. */
1032 set_per_command_cmd (const char *args
, int from_tty
)
1034 struct cmd_list_element
*list
;
1037 val
= parse_cli_boolean_value (args
);
1039 error (_("Bad value for 'mt set per-command no'."));
1041 for (list
= per_command_setlist
; list
!= NULL
; list
= list
->next
)
1042 if (list
->var_type
== var_boolean
)
1044 gdb_assert (list
->type
== set_cmd
);
1045 do_set_command (args
, from_tty
, list
);
1051 /* The "maintenance selftest" command. */
1054 maintenance_selftest (const char *args
, int from_tty
)
1057 gdb_argv
argv (args
);
1058 selftests::run_tests (argv
.as_array_view ());
1060 printf_filtered (_("\
1061 Selftests have been disabled for this build.\n"));
1066 maintenance_info_selftests (const char *arg
, int from_tty
)
1069 printf_filtered ("Registered selftests:\n");
1070 selftests::for_each_selftest ([] (const std::string
&name
) {
1071 printf_filtered (" - %s\n", name
.c_str ());
1074 printf_filtered (_("\
1075 Selftests have been disabled for this build.\n"));
1080 void _initialize_maint_cmds ();
1082 _initialize_maint_cmds ()
1084 struct cmd_list_element
*cmd
;
1086 add_basic_prefix_cmd ("maintenance", class_maintenance
, _("\
1087 Commands for use by GDB maintainers.\n\
1088 Includes commands to dump specific internal GDB structures in\n\
1089 a human readable form, to cause GDB to deliberately dump core, etc."),
1090 &maintenancelist
, "maintenance ", 0,
1093 add_com_alias ("mt", "maintenance", class_maintenance
, 1);
1095 add_basic_prefix_cmd ("info", class_maintenance
, _("\
1096 Commands for showing internal info about the program being debugged."),
1097 &maintenanceinfolist
, "maintenance info ", 0,
1099 add_alias_cmd ("i", "info", class_maintenance
, 1, &maintenancelist
);
1101 const auto opts
= make_maint_info_sections_options_def_group (nullptr);
1102 static std::string maint_info_sections_command_help
1103 = gdb::option::build_help (_("\
1104 List the BFD sections of the exec and core files.\n\
1106 Usage: maintenance info sections [-all-objects] [FILTERS]\n\
1108 FILTERS is a list of words, each word is either:\n\
1109 + A section name - any section with this name will be printed, or\n\
1110 + A section flag - any section with this flag will be printed. The\n\
1112 ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
1113 HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
1115 Sections matching any of the FILTERS will be listed (no FILTERS implies\n\
1116 all sections should be printed).\n\
1120 cmd
= add_cmd ("sections", class_maintenance
, maintenance_info_sections
,
1121 maint_info_sections_command_help
.c_str (),
1122 &maintenanceinfolist
);
1123 set_cmd_completer_handle_brkchars (cmd
, maint_info_sections_completer
);
1125 add_basic_prefix_cmd ("print", class_maintenance
,
1126 _("Maintenance command for printing GDB internal state."),
1127 &maintenanceprintlist
, "maintenance print ", 0,
1130 add_basic_prefix_cmd ("flush", class_maintenance
,
1131 _("Maintenance command for flushing GDB internal caches."),
1132 &maintenanceflushlist
, "maintenance flush ", 0,
1135 add_basic_prefix_cmd ("set", class_maintenance
, _("\
1136 Set GDB internal variables used by the GDB maintainer.\n\
1137 Configure variables internal to GDB that aid in GDB's maintenance"),
1138 &maintenance_set_cmdlist
, "maintenance set ",
1142 add_show_prefix_cmd ("show", class_maintenance
, _("\
1143 Show GDB internal variables used by the GDB maintainer.\n\
1144 Configure variables internal to GDB that aid in GDB's maintenance"),
1145 &maintenance_show_cmdlist
, "maintenance show ",
1149 cmd
= add_cmd ("with", class_maintenance
, maintenance_with_cmd
, _("\
1150 Like \"with\", but works with \"maintenance set\" variables.\n\
1151 Usage: maintenance with SETTING [VALUE] [-- COMMAND]\n\
1152 With no COMMAND, repeats the last executed command.\n\
1153 SETTING is any setting you can change with the \"maintenance set\"\n\
1156 set_cmd_completer_handle_brkchars (cmd
, maintenance_with_cmd_completer
);
1159 add_cmd ("dump-me", class_maintenance
, maintenance_dump_me
, _("\
1160 Get fatal error; make debugger dump its core.\n\
1161 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
1162 itself a SIGQUIT signal."),
1166 add_cmd ("internal-error", class_maintenance
,
1167 maintenance_internal_error
, _("\
1168 Give GDB an internal error.\n\
1169 Cause GDB to behave as if an internal error was detected."),
1172 add_cmd ("internal-warning", class_maintenance
,
1173 maintenance_internal_warning
, _("\
1174 Give GDB an internal warning.\n\
1175 Cause GDB to behave as if an internal warning was reported."),
1178 add_cmd ("demangler-warning", class_maintenance
,
1179 maintenance_demangler_warning
, _("\
1180 Give GDB a demangler warning.\n\
1181 Cause GDB to behave as if a demangler warning was reported."),
1184 cmd
= add_cmd ("demangle", class_maintenance
, maintenance_demangle
, _("\
1185 This command has been moved to \"demangle\"."),
1187 deprecate_cmd (cmd
, "demangle");
1189 add_prefix_cmd ("per-command", class_maintenance
, set_per_command_cmd
, _("\
1190 Per-command statistics settings."),
1191 &per_command_setlist
, "maintenance set per-command ",
1192 1/*allow-unknown*/, &maintenance_set_cmdlist
);
1194 add_show_prefix_cmd ("per-command", class_maintenance
, _("\
1195 Show per-command statistics settings."),
1196 &per_command_showlist
, "maintenance show per-command ",
1197 0/*allow-unknown*/, &maintenance_show_cmdlist
);
1199 add_setshow_boolean_cmd ("time", class_maintenance
,
1200 &per_command_time
, _("\
1201 Set whether to display per-command execution time."), _("\
1202 Show whether to display per-command execution time."),
1204 If enabled, the execution time for each command will be\n\
1205 displayed following the command's output."),
1207 &per_command_setlist
, &per_command_showlist
);
1209 add_setshow_boolean_cmd ("space", class_maintenance
,
1210 &per_command_space
, _("\
1211 Set whether to display per-command space usage."), _("\
1212 Show whether to display per-command space usage."),
1214 If enabled, the space usage for each command will be\n\
1215 displayed following the command's output."),
1217 &per_command_setlist
, &per_command_showlist
);
1219 add_setshow_boolean_cmd ("symtab", class_maintenance
,
1220 &per_command_symtab
, _("\
1221 Set whether to display per-command symtab statistics."), _("\
1222 Show whether to display per-command symtab statistics."),
1224 If enabled, the basic symtab statistics for each command will be\n\
1225 displayed following the command's output."),
1227 &per_command_setlist
, &per_command_showlist
);
1229 /* This is equivalent to "mt set per-command time on".
1230 Kept because some people are used to typing "mt time 1". */
1231 add_cmd ("time", class_maintenance
, maintenance_time_display
, _("\
1232 Set the display of time usage.\n\
1233 If nonzero, will cause the execution time for each command to be\n\
1234 displayed, following the command's output."),
1237 /* This is equivalent to "mt set per-command space on".
1238 Kept because some people are used to typing "mt space 1". */
1239 add_cmd ("space", class_maintenance
, maintenance_space_display
, _("\
1240 Set the display of space usage.\n\
1241 If nonzero, will cause the execution space for each command to be\n\
1242 displayed, following the command's output."),
1245 cmd
= add_cmd ("type", class_maintenance
, maintenance_print_type
, _("\
1246 Print a type chain for a given symbol.\n\
1247 For each node in a type chain, print the raw data for each member of\n\
1248 the type structure, and the interpretation of the data."),
1249 &maintenanceprintlist
);
1250 set_cmd_completer (cmd
, expression_completer
);
1252 add_cmd ("statistics", class_maintenance
, maintenance_print_statistics
,
1253 _("Print statistics about internal gdb state."),
1254 &maintenanceprintlist
);
1256 add_cmd ("architecture", class_maintenance
,
1257 maintenance_print_architecture
, _("\
1258 Print the internal architecture configuration.\n\
1259 Takes an optional file parameter."),
1260 &maintenanceprintlist
);
1262 add_basic_prefix_cmd ("check", class_maintenance
, _("\
1263 Commands for checking internal gdb state."),
1264 &maintenancechecklist
, "maintenance check ", 0,
1267 add_cmd ("translate-address", class_maintenance
,
1268 maintenance_translate_address
,
1269 _("Translate a section name and address to a symbol."),
1272 add_cmd ("deprecate", class_maintenance
, maintenance_deprecate
, _("\
1273 Deprecate a command (for testing purposes).\n\
1274 Usage: maintenance deprecate COMMANDNAME [\"REPLACEMENT\"]\n\
1275 This is used by the testsuite to check the command deprecator.\n\
1276 You probably shouldn't use this,\n\
1277 rather you should use the C function deprecate_cmd()."), &maintenancelist
);
1279 add_cmd ("undeprecate", class_maintenance
, maintenance_undeprecate
, _("\
1280 Undeprecate a command (for testing purposes).\n\
1281 Usage: maintenance undeprecate COMMANDNAME\n\
1282 This is used by the testsuite to check the command deprecator.\n\
1283 You probably shouldn't use this."),
1286 add_cmd ("selftest", class_maintenance
, maintenance_selftest
, _("\
1287 Run gdb's unit tests.\n\
1288 Usage: maintenance selftest [FILTER]\n\
1289 This will run any unit tests that were built in to gdb.\n\
1290 If a filter is given, only the tests with that value in their name will ran."),
1293 add_cmd ("selftests", class_maintenance
, maintenance_info_selftests
,
1294 _("List the registered selftests."), &maintenanceinfolist
);
1296 add_setshow_boolean_cmd ("profile", class_maintenance
,
1297 &maintenance_profile_p
, _("\
1298 Set internal profiling."), _("\
1299 Show internal profiling."), _("\
1300 When enabled GDB is profiled."),
1301 maintenance_set_profile_cmd
,
1302 show_maintenance_profile_p
,
1303 &maintenance_set_cmdlist
,
1304 &maintenance_show_cmdlist
);
1306 add_setshow_zuinteger_unlimited_cmd ("worker-threads",
1308 &n_worker_threads
, _("\
1309 Set the number of worker threads GDB can use."), _("\
1310 Show the number of worker threads GDB can use."), _("\
1311 GDB may use multiple threads to speed up certain CPU-intensive operations,\n\
1312 such as demangling symbol names."),
1313 maintenance_set_worker_threads
, NULL
,
1314 &maintenance_set_cmdlist
,
1315 &maintenance_show_cmdlist
);
1317 update_thread_pool_size ();