#include "defs.h"
#include <ctype.h>
#include <signal.h>
#include "command.h"
#include "gdbcmd.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "demangle.h"
#include "gdbcore.h"
#include "expression.h"
#include "language.h"
#include "symfile.h"
#include "objfiles.h"
#include "value.h"
#include "cli/cli-decode.h"
#include "objc-lang.h"
extern void _initialize_maint_cmds (void);
static void maintenance_command (char *, int);
static void maintenance_dump_me (char *, int);
static void maintenance_internal_error (char *args, int from_tty);
static void maintenance_demangle (char *, int);
static void maintenance_time_display (char *, int);
static void maintenance_space_display (char *, int);
static void maintenance_info_command (char *, int);
static void maintenance_info_sections (char *, int);
static void maintenance_print_command (char *, int);
static void maintenance_do_deprecate (char *, int);
int watchdog = 0;
static void
show_watchdog (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
}
static void
maintenance_command (char *args, int from_tty)
{
printf_unfiltered (_("\"maintenance\" must be followed by the name of a maintenance command.\n"));
help_list (maintenancelist, "maintenance ", -1, gdb_stdout);
}
#ifndef _WIN32
static void
maintenance_dump_me (char *args, int from_tty)
{
if (query ("Should GDB dump core? "))
{
#ifdef __DJGPP__
signal (SIGABRT, SIG_DFL);
kill (getpid (), SIGABRT);
#else
signal (SIGQUIT, SIG_DFL);
kill (getpid (), SIGQUIT);
#endif
}
}
#endif
static void
maintenance_internal_error (char *args, int from_tty)
{
internal_error (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
}
static void
maintenance_internal_warning (char *args, int from_tty)
{
internal_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
}
static void
maintenance_demangle (char *args, int from_tty)
{
char *demangled;
if (args == NULL || *args == '\0')
{
printf_unfiltered (_("\"maintenance demangle\" takes an argument to demangle.\n"));
}
else
{
#if 0
demangled = language_demangle (current_language, args,
DMGL_ANSI | DMGL_PARAMS);
#endif
switch (current_language->la_language)
{
case language_objc:
demangled = objc_demangle (args, 0);
break;
case language_objcplus:
case language_cplus:
default:
demangled = cplus_demangle (args, DMGL_ANSI | DMGL_PARAMS);
break;
}
if (demangled != NULL)
{
printf_unfiltered ("%s\n", demangled);
xfree (demangled);
}
else
{
printf_unfiltered (_("Can't demangle \"%s\"\n"), args);
}
}
}
static void
maintenance_time_display (char *args, int from_tty)
{
extern int display_time;
if (args == NULL || *args == '\0')
printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
else
display_time = strtol (args, NULL, 10);
}
static void
maintenance_space_display (char *args, int from_tty)
{
extern int display_space;
if (args == NULL || *args == '\0')
printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
else
display_space = strtol (args, NULL, 10);
}
static void
maintenance_info_command (char *arg, int from_tty)
{
printf_unfiltered (_("\"maintenance info\" must be followed by the name of an info command.\n"));
help_list (maintenanceinfolist, "maintenance info ", -1, gdb_stdout);
}
static int
match_substring (const char *string, const char *substr)
{
int substr_len = strlen(substr);
const char *tok;
while ((tok = strstr (string, substr)) != NULL)
{
if (tok == string
|| tok[-1] == ' '
|| tok[-1] == '\t')
{
if (tok[substr_len] == ' '
|| tok[substr_len] == '\t'
|| tok[substr_len] == '\0')
{
return 1;
}
}
string = tok + 1;
}
return 0;
}
static int
match_bfd_flags (char *string, flagword flags)
{
if (flags & SEC_ALLOC)
if (match_substring (string, "ALLOC"))
return 1;
if (flags & SEC_LOAD)
if (match_substring (string, "LOAD"))
return 1;
if (flags & SEC_RELOC)
if (match_substring (string, "RELOC"))
return 1;
if (flags & SEC_READONLY)
if (match_substring (string, "READONLY"))
return 1;
if (flags & SEC_CODE)
if (match_substring (string, "CODE"))
return 1;
if (flags & SEC_DATA)
if (match_substring (string, "DATA"))
return 1;
if (flags & SEC_ROM)
if (match_substring (string, "ROM"))
return 1;
if (flags & SEC_CONSTRUCTOR)
if (match_substring (string, "CONSTRUCTOR"))
return 1;
if (flags & SEC_HAS_CONTENTS)
if (match_substring (string, "HAS_CONTENTS"))
return 1;
if (flags & SEC_NEVER_LOAD)
if (match_substring (string, "NEVER_LOAD"))
return 1;
if (flags & SEC_COFF_SHARED_LIBRARY)
if (match_substring (string, "COFF_SHARED_LIBRARY"))
return 1;
if (flags & SEC_IS_COMMON)
if (match_substring (string, "IS_COMMON"))
return 1;
return 0;
}
static void
print_bfd_flags (flagword flags)
{
if (flags & SEC_ALLOC)
printf_filtered (" ALLOC");
if (flags & SEC_LOAD)
printf_filtered (" LOAD");
if (flags & SEC_RELOC)
printf_filtered (" RELOC");
if (flags & SEC_READONLY)
printf_filtered (" READONLY");
if (flags & SEC_CODE)
printf_filtered (" CODE");
if (flags & SEC_DATA)
printf_filtered (" DATA");
if (flags & SEC_ROM)
printf_filtered (" ROM");
if (flags & SEC_CONSTRUCTOR)
printf_filtered (" CONSTRUCTOR");
if (flags & SEC_HAS_CONTENTS)
printf_filtered (" HAS_CONTENTS");
if (flags & SEC_NEVER_LOAD)
printf_filtered (" NEVER_LOAD");
if (flags & SEC_COFF_SHARED_LIBRARY)
printf_filtered (" COFF_SHARED_LIBRARY");
if (flags & SEC_IS_COMMON)
printf_filtered (" IS_COMMON");
}
static void
maint_print_section_info (const char *name, flagword flags,
CORE_ADDR addr, CORE_ADDR endaddr,
unsigned long filepos)
{
printf_filtered (" 0x%s", paddr (addr));
printf_filtered ("->0x%s", paddr (endaddr));
printf_filtered (" at %s",
hex_string_custom ((unsigned long) filepos, 8));
printf_filtered (": %s", name);
print_bfd_flags (flags);
printf_filtered ("\n");
}
static void
print_bfd_section_info (bfd *abfd,
asection *asect,
void *arg)
{
flagword flags = bfd_get_section_flags (abfd, asect);
const char *name = bfd_section_name (abfd, asect);
if (arg == NULL || *((char *) arg) == '\0'
|| match_substring ((char *) arg, name)
|| match_bfd_flags ((char *) arg, flags))
{
CORE_ADDR addr, endaddr;
addr = bfd_section_vma (abfd, asect);
endaddr = addr + bfd_section_size (abfd, asect);
maint_print_section_info (name, flags, addr, endaddr, asect->filepos);
}
}
static void
print_objfile_section_info (bfd *abfd,
struct obj_section *asect,
char *string)
{
flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
const char *name = bfd_section_name (abfd, asect->the_bfd_section);
if (string == NULL || *string == '\0'
|| match_substring (string, name)
|| match_bfd_flags (string, flags))
{
maint_print_section_info (name, flags, asect->addr, asect->endaddr,
asect->the_bfd_section->filepos);
}
}
static void
maintenance_info_sections (char *arg, int from_tty)
{
if (exec_bfd)
{
printf_filtered (_("Exec file:\n"));
printf_filtered (" `%s', ", bfd_get_filename (exec_bfd));
wrap_here (" ");
printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
if (arg && *arg && match_substring (arg, "ALLOBJ"))
{
struct objfile *ofile;
struct obj_section *osect;
if (strcmp (arg, "ALLOBJ") == 0)
arg = NULL;
ALL_OBJFILES (ofile)
{
printf_filtered (_(" Object file: %s\n"),
bfd_get_filename (ofile->obfd));
ALL_OBJFILE_OSECTIONS (ofile, osect)
{
print_objfile_section_info (ofile->obfd, osect, arg);
}
}
}
else
bfd_map_over_sections (exec_bfd, print_bfd_section_info, arg);
}
if (core_bfd)
{
printf_filtered (_("Core file:\n"));
printf_filtered (" `%s', ", bfd_get_filename (core_bfd));
wrap_here (" ");
printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
}
}
void
maintenance_print_statistics (char *args, int from_tty)
{
print_objfile_statistics ();
print_symbol_bcache_statistics ();
}
static void
maintenance_print_architecture (char *args, int from_tty)
{
if (args == NULL)
gdbarch_dump (current_gdbarch, gdb_stdout);
else
{
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
perror_with_name (_("maintenance print architecture"));
gdbarch_dump (current_gdbarch, file);
ui_file_delete (file);
}
}
static void
maintenance_print_command (char *arg, int from_tty)
{
printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
}
static void
maintenance_translate_address (char *arg, int from_tty)
{
CORE_ADDR address;
asection *sect;
char *p;
struct minimal_symbol *sym;
struct objfile *objfile;
if (arg == NULL || *arg == 0)
error (_("requires argument (address or section + address)"));
sect = NULL;
p = arg;
if (!isdigit (*p))
{
while (*p && !isspace (*p))
p++;
if (*p == '\000')
error (_("Need to specify <section-name> and <address>"));
*p++ = '\000';
while (isspace (*p))
p++;
ALL_OBJFILES (objfile)
{
sect = bfd_get_section_by_name (objfile->obfd, arg);
if (sect != NULL)
break;
}
if (!sect)
error (_("Unknown section %s."), arg);
}
address = parse_and_eval_address (p);
if (sect)
sym = lookup_minimal_symbol_by_pc_section (address, sect);
else
sym = lookup_minimal_symbol_by_pc (address);
if (sym)
printf_filtered ("%s+%s\n",
SYMBOL_PRINT_NAME (sym),
paddr_u (address - SYMBOL_VALUE_ADDRESS (sym)));
else if (sect)
printf_filtered (_("no symbol at %s:0x%s\n"), sect->name, paddr (address));
else
printf_filtered (_("no symbol at 0x%s\n"), paddr (address));
return;
}
static void
maintenance_deprecate (char *args, int from_tty)
{
if (args == NULL || *args == '\0')
{
printf_unfiltered (_("\"maintenance deprecate\" takes an argument, \n\
the command you want to deprecate, and optionally the replacement command \n\
enclosed in quotes.\n"));
}
maintenance_do_deprecate (args, 1);
}
static void
maintenance_undeprecate (char *args, int from_tty)
{
if (args == NULL || *args == '\0')
{
printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
the command you want to undeprecate.\n"));
}
maintenance_do_deprecate (args, 0);
}
static void
maintenance_do_deprecate (char *text, int deprecate)
{
struct cmd_list_element *alias = NULL;
struct cmd_list_element *prefix_cmd = NULL;
struct cmd_list_element *cmd = NULL;
char *start_ptr = NULL;
char *end_ptr = NULL;
int len;
char *replacement = NULL;
if (text == NULL)
return;
if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
{
printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
return;
}
if (deprecate)
{
start_ptr = strchr (text, '\"');
if (start_ptr != NULL)
{
start_ptr++;
end_ptr = strrchr (start_ptr, '\"');
if (end_ptr != NULL)
{
len = end_ptr - start_ptr;
start_ptr[len] = '\0';
replacement = xstrdup (start_ptr);
}
}
}
if (!start_ptr || !end_ptr)
replacement = NULL;
if (alias)
{
if (alias->flags & MALLOCED_REPLACEMENT)
xfree (alias->replacement);
if (deprecate)
alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
else
alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
alias->replacement = replacement;
alias->flags |= MALLOCED_REPLACEMENT;
return;
}
else if (cmd)
{
if (cmd->flags & MALLOCED_REPLACEMENT)
xfree (cmd->replacement);
if (deprecate)
cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
else
cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
cmd->replacement = replacement;
cmd->flags |= MALLOCED_REPLACEMENT;
return;
}
}
struct cmd_list_element *maintenance_set_cmdlist;
struct cmd_list_element *maintenance_show_cmdlist;
static void
maintenance_set_cmd (char *args, int from_tty)
{
printf_unfiltered (_("\"maintenance set\" must be followed by the name of a set command.\n"));
help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
}
static void
maintenance_show_cmd (char *args, int from_tty)
{
cmd_show_list (maintenance_show_cmdlist, from_tty, "");
}
static int maintenance_profile_p;
static void
show_maintenance_profile_p (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
}
#if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP)
#ifdef HAVE__ETEXT
extern char _etext;
#define TEXTEND &_etext
#else
extern char etext;
#define TEXTEND &etext
#endif
static int profiling_state;
static void
mcleanup_wrapper (void)
{
extern void _mcleanup (void);
if (profiling_state)
_mcleanup ();
}
static void
maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
{
if (maintenance_profile_p == profiling_state)
return;
profiling_state = maintenance_profile_p;
if (maintenance_profile_p)
{
static int profiling_initialized;
extern void monstartup (unsigned long, unsigned long);
extern int main();
if (!profiling_initialized)
{
atexit (mcleanup_wrapper);
profiling_initialized = 1;
}
monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
}
else
{
extern void _mcleanup (void);
_mcleanup ();
}
}
#else
static void
maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
{
error (_("Profiling support is not available on this system."));
}
#endif
struct gdb_timer
{
char *name;
int running;
char *last_mssg;
long last_start;
long total_time;
long last_interval;
long child_times;
};
struct gdb_timer_stack
{
struct gdb_timer *timer;
struct gdb_timer_stack *next;
};
static struct gdb_timer *timer_list;
static struct gdb_timer_stack *timer_stack;
static char *active_timer_list;
static int max_timers = 0;
static int n_timers = 0;
int maint_use_timers = 0;
static void
maintenance_interval_display (char *args, int from_tty)
{
extern int display_time;
if (args == NULL || *args == '\0')
printf_unfiltered (_("\"maintenance interval\" takes \"all\", \"off\" or a list of timers.\n"));
else if (strcmp (args, "off") == 0)
{
maint_use_timers = 0;
if (active_timer_list != NULL)
xfree (active_timer_list);
active_timer_list = NULL;
}
else
{
maint_use_timers = 1;
if (active_timer_list != NULL)
xfree (active_timer_list);
if (strcmp (args, "all") == 0)
active_timer_list = NULL;
else
active_timer_list = xstrdup (args);
}
}
static int
init_timer (char *name)
{
int this_timer;
if (n_timers == max_timers)
{
max_timers += 64;
timer_list = (struct gdb_timer *)
xrealloc (timer_list, max_timers * sizeof (struct gdb_timer *));
}
this_timer = n_timers;
n_timers++;
bzero (&timer_list[this_timer], sizeof (struct gdb_timer));
timer_list[this_timer].name = xstrdup (name);
return this_timer;
}
static void
push_timer (struct gdb_timer *timer)
{
struct gdb_timer_stack *next =
(struct gdb_timer_stack *) xmalloc (sizeof (struct gdb_timer_stack));
next->timer = timer;
next->next = timer_stack;
timer_stack = next;
}
void
pop_timer (void)
{
struct gdb_timer_stack *this_timer = timer_stack;
struct gdb_timer_stack *next_timer = timer_stack->next;
if (next_timer != NULL)
next_timer->timer->child_times += this_timer->timer->last_interval
+ this_timer->timer->child_times;
timer_stack = next_timer;
xfree (this_timer);
}
static void
stop_timer (struct gdb_timer *timer)
{
timer->last_interval = get_run_time () - timer->last_start - timer->child_times;
timer->total_time += timer->last_interval;
}
static void
report_timer_internal (struct gdb_timer *timer, int last_interval_p)
{
struct cleanup *notify_cleanup;
notify_cleanup = make_cleanup_ui_out_notify_begin_end (uiout, "timer-data");
ui_out_text (uiout, "\n*+*+* Timer ");
ui_out_field_string (uiout, "name", timer->name);
if (last_interval_p)
{
ui_out_text (uiout, " - ");
ui_out_field_string (uiout, "mssg", timer->last_mssg);
}
ui_out_text (uiout, " total: ");
ui_out_field_fmt (uiout, "total", "%0.5f", timer->total_time/ 1000000.0);
if (last_interval_p)
{
ui_out_text (uiout, " interval: ");
ui_out_field_fmt (uiout, "interval", "%0.5f", timer->last_interval / 1000000.0);
ui_out_text (uiout, " child times: ");
ui_out_field_fmt (uiout, "child", "%0.5f", timer->child_times / 1000000.0);
}
ui_out_text (uiout, " *-*-*\n");
if (last_interval_p)
xfree (timer->last_mssg);
do_cleanups (notify_cleanup);
}
static void
maintenance_report_interval_command (char *args, int is_tty)
{
int i;
for (i = 0; i < n_timers; i++)
report_timer_internal (&timer_list[i], 0);
}
static void
stop_report_timer (void *ptr)
{
struct gdb_timer *timer = (struct gdb_timer *) ptr;
if (timer_stack->timer != timer)
internal_error (__FILE__, __LINE__, "stoping timer not on top of stack: "
"timer %s top of stack: %s", timer->name, timer_stack->timer->name);
stop_timer (timer);
report_timer_internal (timer, 1);
pop_timer ();
}
static struct cleanup *
make_cleanup_start_report_timer (int timer_id, char *string)
{
struct gdb_timer *timer;
if (timer_id == -1)
return make_cleanup (null_cleanup, NULL);
if (timer_id > n_timers)
error ("Invalid timer in start_timers");
timer = &timer_list[timer_id];
push_timer (timer);
timer->last_start = get_run_time ();
if (string == NULL)
string = "<Unknown>";
timer->last_mssg = xstrdup (string);
timer->last_interval = 0;
timer->child_times = 0;
return make_cleanup (stop_report_timer, timer);
}
int
find_timer (char *name)
{
int i;
if (maint_use_timers == 0)
return -1;
if (active_timer_list != NULL)
{
if (strstr (name, active_timer_list) == NULL)
return -1;
}
for (i = 0; i < n_timers; i++)
{
if (strcmp (timer_list[i].name, name) == 0)
return i;
}
return init_timer (name);
}
struct cleanup *
start_timer (int *timer_var, char *timer_name, char *this_mssg)
{
if (*timer_var == -1)
*timer_var = find_timer (timer_name);
if (*timer_var == -1)
return make_cleanup (null_cleanup, 0);
return make_cleanup_start_report_timer (*timer_var, this_mssg);
}
void
_initialize_maint_cmds (void)
{
add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
Commands for use by GDB maintainers.\n\
Includes commands to dump specific internal GDB structures in\n\
a human readable form, to cause GDB to deliberately dump core,\n\
to test internal functions such as the C++/ObjC demangler, etc."),
&maintenancelist, "maintenance ", 0,
&cmdlist);
add_com_alias ("mt", "maintenance", class_maintenance, 1);
add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
Commands for showing internal info about the program being debugged."),
&maintenanceinfolist, "maintenance info ", 0,
&maintenancelist);
add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
List the BFD sections of the exec and core files. \n\
Arguments may be any combination of:\n\
[one or more section names]\n\
ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
Sections matching any argument will be listed (no argument\n\
implies all sections). In addition, the special argument\n\
ALLOBJ\n\
lists all sections from all object files, including shared libraries."),
&maintenanceinfolist);
add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
_("Maintenance command for printing GDB internal state."),
&maintenanceprintlist, "maintenance print ", 0,
&maintenancelist);
add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
Set GDB internal variables used by the GDB maintainer.\n\
Configure variables internal to GDB that aid in GDB's maintenance"),
&maintenance_set_cmdlist, "maintenance set ",
0,
&maintenancelist);
add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
Show GDB internal variables used by the GDB maintainer.\n\
Configure variables internal to GDB that aid in GDB's maintenance"),
&maintenance_show_cmdlist, "maintenance show ",
0,
&maintenancelist);
#ifndef _WIN32
add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
Get fatal error; make debugger dump its core.\n\
GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
itself a SIGQUIT signal."),
&maintenancelist);
#endif
add_cmd ("internal-error", class_maintenance,
maintenance_internal_error, _("\
Give GDB an internal error.\n\
Cause GDB to behave as if an internal error was detected."),
&maintenancelist);
add_cmd ("internal-warning", class_maintenance,
maintenance_internal_warning, _("\
Give GDB an internal warning.\n\
Cause GDB to behave as if an internal warning was reported."),
&maintenancelist);
add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
Demangle a C++/ObjC mangled name.\n\
Call internal GDB demangler routine to demangle a C++ link name\n\
and prints the result."),
&maintenancelist);
add_cmd ("time", class_maintenance, maintenance_time_display, _("\
Set the display of time usage.\n\
If nonzero, will cause the execution time for each command to be\n\
displayed, following the command's output."),
&maintenancelist);
add_cmd ("space", class_maintenance, maintenance_space_display, _("\
Set the display of space usage.\n\
If nonzero, will cause the execution space for each command to be\n\
displayed, following the command's output."),
&maintenancelist);
add_cmd ("interval", class_maintenance, maintenance_interval_display, _("\
Set the report of low-level interval timers.\n\
If nonzero, will cause the interval timer data to be gathered and printed."),
&maintenancelist);
add_cmd ("report-interval", class_maintenance, maintenance_report_interval_command, _("\
Report the summary values for all the low-level interval timers."),
&maintenancelist);
add_cmd ("type", class_maintenance, maintenance_print_type, _("\
Print a type chain for a given symbol.\n\
For each node in a type chain, print the raw data for each member of\n\
the type structure, and the interpretation of the data."),
&maintenanceprintlist);
add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
Print dump of current symbol definitions.\n\
Entries in the full symbol table are dumped to file OUTFILE.\n\
If a SOURCE file is specified, dump only that file's symbols."),
&maintenanceprintlist);
add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
Print dump of current minimal symbol definitions.\n\
Entries in the minimal symbol table are dumped to file OUTFILE.\n\
If a SOURCE file is specified, dump only that file's minimal symbols."),
&maintenanceprintlist);
add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
Print dump of current partial symbol definitions.\n\
Entries in the partial symbol table are dumped to file OUTFILE.\n\
If a SOURCE file is specified, dump only that file's partial symbols."),
&maintenanceprintlist);
add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
_("Print dump of current object file definitions."),
&maintenanceprintlist);
add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
List the full symbol tables for all object files.\n\
This does not include information about individual symbols, blocks, or\n\
linetables --- just the symbol table structures themselves.\n\
With an argument REGEXP, list the symbol tables whose names that match that."),
&maintenanceinfolist);
add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
List the partial symbol tables for all object files.\n\
This does not include information about individual partial symbols,\n\
just the symbol table structures themselves."),
&maintenanceinfolist);
add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
_("Print statistics about internal gdb state."),
&maintenanceprintlist);
add_cmd ("architecture", class_maintenance,
maintenance_print_architecture, _("\
Print the internal architecture configuration.\n\
Takes an optional file parameter."),
&maintenanceprintlist);
add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
_("Check consistency of psymtabs and symtabs."),
&maintenancelist);
add_cmd ("translate-address", class_maintenance, maintenance_translate_address,
_("Translate a section name and address to a symbol."),
&maintenancelist);
add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
Deprecate a command. Note that this is just in here so the \n\
testsuite can check the comamnd deprecator. You probably shouldn't use this,\n\
rather you should use the C function deprecate_cmd(). If you decide you \n\
want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
replacement is optional."), &maintenancelist);
add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
Undeprecate a command. Note that this is just in here so the \n\
testsuite can check the comamnd deprecator. You probably shouldn't use this,\n\
If you decide you want to use it: maintenance undeprecate 'commandname'"),
&maintenancelist);
add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
Set watchdog timer."), _("\
Show watchdog timer."), _("\
When non-zero, this timeout is used instead of waiting forever for a target\n\
to finish a low-level step or continue operation. If the specified amount\n\
of time passes without a response from the target, an error occurs."),
NULL,
show_watchdog,
&setlist, &showlist);
add_setshow_boolean_cmd ("profile", class_maintenance,
&maintenance_profile_p, _("\
Set internal profiling."), _("\
Show internal profiling."), _("\
When enabled GDB is profiled."),
maintenance_set_profile_cmd,
show_maintenance_profile_p,
&maintenance_set_cmdlist,
&maintenance_show_cmdlist);
}