gdb/maint.c

   1 /* Support for GDB maintenance commands.
   2
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
   4    2003, 2004, 2007 Free Software Foundation, Inc.
   5
   6    Written by Fred Fish at Cygnus Support.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, USA.  */
  24
  25
  26 #include "defs.h"
  27 #include <ctype.h>
  28 #include <signal.h>
  29 #include "command.h"
  30 #include "gdbcmd.h"
  31 #include "symtab.h"
  32 #include "gdbtypes.h"
  33 #include "demangle.h"
  34 #include "gdbcore.h"
  35 #include "expression.h"         /* For language.h */
  36 #include "language.h"
  37 #include "symfile.h"
  38 #include "objfiles.h"
  39 #include "value.h"
  40
  41 #include "cli/cli-decode.h"
  42
  43 extern void _initialize_maint_cmds (void);
  44
  45 static void maintenance_command (char *, int);
  46
  47 static void maintenance_internal_error (char *args, int from_tty);
  48
  49 static void maintenance_demangle (char *, int);
  50
  51 static void maintenance_time_display (char *, int);
  52
  53 static void maintenance_space_display (char *, int);
  54
  55 static void maintenance_info_command (char *, int);
  56
  57 static void maintenance_info_sections (char *, int);
  58
  59 static void maintenance_print_command (char *, int);
  60
  61 static void maintenance_do_deprecate (char *, int);
  62
  63 /* Set this to the maximum number of seconds to wait instead of waiting forever
  64    in target_wait().  If this timer times out, then it generates an error and
  65    the command is aborted.  This replaces most of the need for timeouts in the
  66    GDB test suite, and makes it possible to distinguish between a hung target
  67    and one with slow communications.  */
  68
  69 int watchdog = 0;
  70 static void
  71 show_watchdog (struct ui_file *file, int from_tty,
  72                struct cmd_list_element *c, const char *value)
  73 {
  74   fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
  75 }
  76
  77 /*
  78
  79    LOCAL FUNCTION
  80
  81    maintenance_command -- access the maintenance subcommands
  82
  83    SYNOPSIS
  84
  85    void maintenance_command (char *args, int from_tty)
  86
  87    DESCRIPTION
  88
  89  */
  90
  91 static void
  92 maintenance_command (char *args, int from_tty)
  93 {
  94   printf_unfiltered (_("\"maintenance\" must be followed by the name of a maintenance command.\n"));
  95   help_list (maintenancelist, "maintenance ", -1, gdb_stdout);
  96 }
  97
  98 #ifndef _WIN32
  99 static void
 100 maintenance_dump_me (char *args, int from_tty)
 101 {
 102   if (query ("Should GDB dump core? "))
 103     {
 104 #ifdef __DJGPP__
 105       /* SIGQUIT by default is ignored, so use SIGABRT instead.  */
 106       signal (SIGABRT, SIG_DFL);
 107       kill (getpid (), SIGABRT);
 108 #else
 109       signal (SIGQUIT, SIG_DFL);
 110       kill (getpid (), SIGQUIT);
 111 #endif
 112     }
 113 }
 114 #endif
 115
 116 /* Stimulate the internal error mechanism that GDB uses when an
 117    internal problem is detected.  Allows testing of the mechanism.
 118    Also useful when the user wants to drop a core file but not exit
 119    GDB. */
 120
 121 static void
 122 maintenance_internal_error (char *args, int from_tty)
 123 {
 124   internal_error (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
 125 }
 126
 127 /* Stimulate the internal error mechanism that GDB uses when an
 128    internal problem is detected.  Allows testing of the mechanism.
 129    Also useful when the user wants to drop a core file but not exit
 130    GDB. */
 131
 132 static void
 133 maintenance_internal_warning (char *args, int from_tty)
 134 {
 135   internal_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
 136 }
 137
 138 /* Someday we should allow demangling for things other than just
 139    explicit strings.  For example, we might want to be able to specify
 140    the address of a string in either GDB's process space or the
 141    debuggee's process space, and have gdb fetch and demangle that
 142    string.  If we have a char* pointer "ptr" that points to a string,
 143    we might want to be able to given just the name and have GDB
 144    demangle and print what it points to, etc.  (FIXME) */
 145
 146 static void
 147 maintenance_demangle (char *args, int from_tty)
 148 {
 149   char *demangled;
 150
 151   if (args == NULL || *args == '\0')
 152     {
 153       printf_unfiltered (_("\"maintenance demangle\" takes an argument to demangle.\n"));
 154     }
 155   else
 156     {
 157       demangled = language_demangle (current_language, args,
 158                                      DMGL_ANSI | DMGL_PARAMS);
 159       if (demangled != NULL)
 160         {
 161           printf_unfiltered ("%s\n", demangled);
 162           xfree (demangled);
 163         }
 164       else
 165         {
 166           printf_unfiltered (_("Can't demangle \"%s\"\n"), args);
 167         }
 168     }
 169 }
 170
 171 static void
 172 maintenance_time_display (char *args, int from_tty)
 173 {
 174   extern int display_time;
 175
 176   if (args == NULL || *args == '\0')
 177     printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
 178   else
 179     display_time = strtol (args, NULL, 10);
 180 }
 181
 182 static void
 183 maintenance_space_display (char *args, int from_tty)
 184 {
 185   extern int display_space;
 186
 187   if (args == NULL || *args == '\0')
 188     printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
 189   else
 190     display_space = strtol (args, NULL, 10);
 191 }
 192
 193 /* The "maintenance info" command is defined as a prefix, with
 194    allow_unknown 0.  Therefore, its own definition is called only for
 195    "maintenance info" with no args.  */
 196
 197 static void
 198 maintenance_info_command (char *arg, int from_tty)
 199 {
 200   printf_unfiltered (_("\"maintenance info\" must be followed by the name of an info command.\n"));
 201   help_list (maintenanceinfolist, "maintenance info ", -1, gdb_stdout);
 202 }
 203
 204 /* Mini tokenizing lexer for 'maint info sections' command.  */
 205
 206 static int
 207 match_substring (const char *string, const char *substr)
 208 {
 209   int substr_len = strlen(substr);
 210   const char *tok;
 211
 212   while ((tok = strstr (string, substr)) != NULL)
 213     {
 214       /* Got a partial match.  Is it a whole word? */
 215       if (tok == string
 216           || tok[-1] == ' '
 217           || tok[-1] == '\t')
 218       {
 219         /* Token is delimited at the front... */
 220         if (tok[substr_len] == ' '
 221             || tok[substr_len] == '\t'
 222             || tok[substr_len] == '\0')
 223         {
 224           /* Token is delimited at the rear.  Got a whole-word match.  */
 225           return 1;
 226         }
 227       }
 228       /* Token didn't match as a whole word.  Advance and try again.  */
 229       string = tok + 1;
 230     }
 231   return 0;
 232 }
 233
 234 static int
 235 match_bfd_flags (char *string, flagword flags)
 236 {
 237   if (flags & SEC_ALLOC)
 238     if (match_substring (string, "ALLOC"))
 239       return 1;
 240   if (flags & SEC_LOAD)
 241     if (match_substring (string, "LOAD"))
 242       return 1;
 243   if (flags & SEC_RELOC)
 244     if (match_substring (string, "RELOC"))
 245       return 1;
 246   if (flags & SEC_READONLY)
 247     if (match_substring (string, "READONLY"))
 248       return 1;
 249   if (flags & SEC_CODE)
 250     if (match_substring (string, "CODE"))
 251       return 1;
 252   if (flags & SEC_DATA)
 253     if (match_substring (string, "DATA"))
 254       return 1;
 255   if (flags & SEC_ROM)
 256     if (match_substring (string, "ROM"))
 257       return 1;
 258   if (flags & SEC_CONSTRUCTOR)
 259     if (match_substring (string, "CONSTRUCTOR"))
 260       return 1;
 261   if (flags & SEC_HAS_CONTENTS)
 262     if (match_substring (string, "HAS_CONTENTS"))
 263       return 1;
 264   if (flags & SEC_NEVER_LOAD)
 265     if (match_substring (string, "NEVER_LOAD"))
 266       return 1;
 267   if (flags & SEC_COFF_SHARED_LIBRARY)
 268     if (match_substring (string, "COFF_SHARED_LIBRARY"))
 269       return 1;
 270   if (flags & SEC_IS_COMMON)
 271     if (match_substring (string, "IS_COMMON"))
 272       return 1;
 273
 274   return 0;
 275 }
 276
 277 static void
 278 print_bfd_flags (flagword flags)
 279 {
 280   if (flags & SEC_ALLOC)
 281     printf_filtered (" ALLOC");
 282   if (flags & SEC_LOAD)
 283     printf_filtered (" LOAD");
 284   if (flags & SEC_RELOC)
 285     printf_filtered (" RELOC");
 286   if (flags & SEC_READONLY)
 287     printf_filtered (" READONLY");
 288   if (flags & SEC_CODE)
 289     printf_filtered (" CODE");
 290   if (flags & SEC_DATA)
 291     printf_filtered (" DATA");
 292   if (flags & SEC_ROM)
 293     printf_filtered (" ROM");
 294   if (flags & SEC_CONSTRUCTOR)
 295     printf_filtered (" CONSTRUCTOR");
 296   if (flags & SEC_HAS_CONTENTS)
 297     printf_filtered (" HAS_CONTENTS");
 298   if (flags & SEC_NEVER_LOAD)
 299     printf_filtered (" NEVER_LOAD");
 300   if (flags & SEC_COFF_SHARED_LIBRARY)
 301     printf_filtered (" COFF_SHARED_LIBRARY");
 302   if (flags & SEC_IS_COMMON)
 303     printf_filtered (" IS_COMMON");
 304 }
 305
 306 static void
 307 maint_print_section_info (const char *name, flagword flags,
 308                           CORE_ADDR addr, CORE_ADDR endaddr,
 309                           unsigned long filepos)
 310 {
 311   /* FIXME-32x64: Need deprecated_print_address_numeric with field
 312      width.  */
 313   printf_filtered ("    0x%s", paddr (addr));
 314   printf_filtered ("->0x%s", paddr (endaddr));
 315   printf_filtered (" at %s",
 316                    hex_string_custom ((unsigned long) filepos, 8));
 317   printf_filtered (": %s", name);
 318   print_bfd_flags (flags);
 319   printf_filtered ("\n");
 320 }
 321
 322 static void
 323 print_bfd_section_info (bfd *abfd,
 324                         asection *asect,
 325                         void *arg)
 326 {
 327   flagword flags = bfd_get_section_flags (abfd, asect);
 328   const char *name = bfd_section_name (abfd, asect);
 329
 330   if (arg == NULL || *((char *) arg) == '\0'
 331       || match_substring ((char *) arg, name)
 332       || match_bfd_flags ((char *) arg, flags))
 333     {
 334       CORE_ADDR addr, endaddr;
 335
 336       addr = bfd_section_vma (abfd, asect);
 337       endaddr = addr + bfd_section_size (abfd, asect);
 338       maint_print_section_info (name, flags, addr, endaddr, asect->filepos);
 339     }
 340 }
 341
 342 static void
 343 print_objfile_section_info (bfd *abfd,
 344                             struct obj_section *asect,
 345                             char *string)
 346 {
 347   flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
 348   const char *name = bfd_section_name (abfd, asect->the_bfd_section);
 349
 350   if (string == NULL || *string == '\0'
 351       || match_substring (string, name)
 352       || match_bfd_flags (string, flags))
 353     {
 354       maint_print_section_info (name, flags, asect->addr, asect->endaddr,
 355                           asect->the_bfd_section->filepos);
 356     }
 357 }
 358
 359 static void
 360 maintenance_info_sections (char *arg, int from_tty)
 361 {
 362   if (exec_bfd)
 363     {
 364       printf_filtered (_("Exec file:\n"));
 365       printf_filtered ("    `%s', ", bfd_get_filename (exec_bfd));
 366       wrap_here ("        ");
 367       printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
 368       if (arg && *arg && match_substring (arg, "ALLOBJ"))
 369         {
 370           struct objfile *ofile;
 371           struct obj_section *osect;
 372
 373           /* Only this function cares about the 'ALLOBJ' argument;
 374              if 'ALLOBJ' is the only argument, discard it rather than
 375              passing it down to print_objfile_section_info (which
 376              wouldn't know how to handle it).  */
 377           if (strcmp (arg, "ALLOBJ") == 0)
 378             arg = NULL;
 379
 380           ALL_OBJFILES (ofile)
 381             {
 382               printf_filtered (_("  Object file: %s\n"),
 383                                bfd_get_filename (ofile->obfd));
 384               ALL_OBJFILE_OSECTIONS (ofile, osect)
 385                 {
 386                   print_objfile_section_info (ofile->obfd, osect, arg);
 387                 }
 388             }
 389         }
 390       else
 391         bfd_map_over_sections (exec_bfd, print_bfd_section_info, arg);
 392     }
 393
 394   if (core_bfd)
 395     {
 396       printf_filtered (_("Core file:\n"));
 397       printf_filtered ("    `%s', ", bfd_get_filename (core_bfd));
 398       wrap_here ("        ");
 399       printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
 400       bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
 401     }
 402 }
 403
 404 void
 405 maintenance_print_statistics (char *args, int from_tty)
 406 {
 407   print_objfile_statistics ();
 408   print_symbol_bcache_statistics ();
 409 }
 410
 411 static void
 412 maintenance_print_architecture (char *args, int from_tty)
 413 {
 414   if (args == NULL)
 415     gdbarch_dump (current_gdbarch, gdb_stdout);
 416   else
 417     {
 418       struct ui_file *file = gdb_fopen (args, "w");
 419       if (file == NULL)
 420         perror_with_name (_("maintenance print architecture"));
 421       gdbarch_dump (current_gdbarch, file);
 422       ui_file_delete (file);
 423     }
 424 }
 425
 426 /* The "maintenance print" command is defined as a prefix, with
 427    allow_unknown 0.  Therefore, its own definition is called only for
 428    "maintenance print" with no args.  */
 429
 430 static void
 431 maintenance_print_command (char *arg, int from_tty)
 432 {
 433   printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
 434   help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
 435 }
 436
 437 /* The "maintenance translate-address" command converts a section and address
 438    to a symbol.  This can be called in two ways:
 439    maintenance translate-address <secname> <addr>
 440    or   maintenance translate-address <addr>
 441  */
 442
 443 static void
 444 maintenance_translate_address (char *arg, int from_tty)
 445 {
 446   CORE_ADDR address;
 447   asection *sect;
 448   char *p;
 449   struct minimal_symbol *sym;
 450   struct objfile *objfile;
 451
 452   if (arg == NULL || *arg == 0)
 453     error (_("requires argument (address or section + address)"));
 454
 455   sect = NULL;
 456   p = arg;
 457
 458   if (!isdigit (*p))
 459     {                           /* See if we have a valid section name */
 460       while (*p && !isspace (*p))       /* Find end of section name */
 461         p++;
 462       if (*p == '\000')         /* End of command? */
 463         error (_("Need to specify <section-name> and <address>"));
 464       *p++ = '\000';
 465       while (isspace (*p))
 466         p++;                    /* Skip whitespace */
 467
 468       ALL_OBJFILES (objfile)
 469       {
 470         sect = bfd_get_section_by_name (objfile->obfd, arg);
 471         if (sect != NULL)
 472           break;
 473       }
 474
 475       if (!sect)
 476         error (_("Unknown section %s."), arg);
 477     }
 478
 479   address = parse_and_eval_address (p);
 480
 481   if (sect)
 482     sym = lookup_minimal_symbol_by_pc_section (address, sect);
 483   else
 484     sym = lookup_minimal_symbol_by_pc (address);
 485
 486   if (sym)
 487     printf_filtered ("%s+%s\n",
 488                      SYMBOL_PRINT_NAME (sym),
 489                      paddr_u (address - SYMBOL_VALUE_ADDRESS (sym)));
 490   else if (sect)
 491     printf_filtered (_("no symbol at %s:0x%s\n"), sect->name, paddr (address));
 492   else
 493     printf_filtered (_("no symbol at 0x%s\n"), paddr (address));
 494
 495   return;
 496 }
 497
 498
 499 /* When a command is deprecated the user will be warned the first time
 500    the command is used.  If possible, a replacement will be
 501    offered. */
 502
 503 static void
 504 maintenance_deprecate (char *args, int from_tty)
 505 {
 506   if (args == NULL || *args == '\0')
 507     {
 508       printf_unfiltered (_("\"maintenance deprecate\" takes an argument, \n\
 509 the command you want to deprecate, and optionally the replacement command \n\
 510 enclosed in quotes.\n"));
 511     }
 512
 513   maintenance_do_deprecate (args, 1);
 514
 515 }
 516
 517
 518 static void
 519 maintenance_undeprecate (char *args, int from_tty)
 520 {
 521   if (args == NULL || *args == '\0')
 522     {
 523       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 524 the command you want to undeprecate.\n"));
 525     }
 526
 527   maintenance_do_deprecate (args, 0);
 528
 529 }
 530
 531 /* You really shouldn't be using this. It is just for the testsuite.
 532    Rather, you should use deprecate_cmd() when the command is created
 533    in _initialize_blah().
 534
 535    This function deprecates a command and optionally assigns it a
 536    replacement.  */
 537
 538 static void
 539 maintenance_do_deprecate (char *text, int deprecate)
 540 {
 541
 542   struct cmd_list_element *alias = NULL;
 543   struct cmd_list_element *prefix_cmd = NULL;
 544   struct cmd_list_element *cmd = NULL;
 545
 546   char *start_ptr = NULL;
 547   char *end_ptr = NULL;
 548   int len;
 549   char *replacement = NULL;
 550
 551   if (text == NULL)
 552     return;
 553
 554   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 555     {
 556       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 557       return;
 558     }
 559
 560   if (deprecate)
 561     {
 562       /* look for a replacement command */
 563       start_ptr = strchr (text, '\"');
 564       if (start_ptr != NULL)
 565         {
 566           start_ptr++;
 567           end_ptr = strrchr (start_ptr, '\"');
 568           if (end_ptr != NULL)
 569             {
 570               len = end_ptr - start_ptr;
 571               start_ptr[len] = '\0';
 572               replacement = xstrdup (start_ptr);
 573             }
 574         }
 575     }
 576
 577   if (!start_ptr || !end_ptr)
 578     replacement = NULL;
 579
 580
 581   /* If they used an alias, we only want to deprecate the alias.
 582
 583      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 584      string was allocated at compile time we don't want to free the
 585      memory. */
 586   if (alias)
 587     {
 588
 589       if (alias->flags & MALLOCED_REPLACEMENT)
 590         xfree (alias->replacement);
 591
 592       if (deprecate)
 593         alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
 594       else
 595         alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
 596       alias->replacement = replacement;
 597       alias->flags |= MALLOCED_REPLACEMENT;
 598       return;
 599     }
 600   else if (cmd)
 601     {
 602       if (cmd->flags & MALLOCED_REPLACEMENT)
 603         xfree (cmd->replacement);
 604
 605       if (deprecate)
 606         cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
 607       else
 608         cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
 609       cmd->replacement = replacement;
 610       cmd->flags |= MALLOCED_REPLACEMENT;
 611       return;
 612     }
 613 }
 614
 615 /* Maintenance set/show framework.  */
 616
 617 struct cmd_list_element *maintenance_set_cmdlist;
 618 struct cmd_list_element *maintenance_show_cmdlist;
 619
 620 static void
 621 maintenance_set_cmd (char *args, int from_tty)
 622 {
 623   printf_unfiltered (_("\"maintenance set\" must be followed by the name of a set command.\n"));
 624   help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
 625 }
 626
 627 static void
 628 maintenance_show_cmd (char *args, int from_tty)
 629 {
 630   cmd_show_list (maintenance_show_cmdlist, from_tty, "");
 631 }
 632
 633 /* Profiling support.  */
 634
 635 static int maintenance_profile_p;
 636 static void
 637 show_maintenance_profile_p (struct ui_file *file, int from_tty,
 638                             struct cmd_list_element *c, const char *value)
 639 {
 640   fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
 641 }
 642
 643 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP)
 644
 645 #ifdef HAVE__ETEXT
 646 extern char _etext;
 647 #define TEXTEND &_etext
 648 #else
 649 extern char etext;
 650 #define TEXTEND &etext
 651 #endif
 652
 653 static int profiling_state;
 654
 655 static void
 656 mcleanup_wrapper (void)
 657 {
 658   extern void _mcleanup (void);
 659
 660   if (profiling_state)
 661     _mcleanup ();
 662 }
 663
 664 static void
 665 maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
 666 {
 667   if (maintenance_profile_p == profiling_state)
 668     return;
 669
 670   profiling_state = maintenance_profile_p;
 671
 672   if (maintenance_profile_p)
 673     {
 674       static int profiling_initialized;
 675
 676       extern void monstartup (unsigned long, unsigned long);
 677       extern int main();
 678
 679       if (!profiling_initialized)
 680         {
 681           atexit (mcleanup_wrapper);
 682           profiling_initialized = 1;
 683         }
 684
 685       /* "main" is now always the first function in the text segment, so use
 686          its address for monstartup.  */
 687       monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
 688     }
 689   else
 690     {
 691       extern void _mcleanup (void);
 692       _mcleanup ();
 693     }
 694 }
 695 #else
 696 static void
 697 maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
 698 {
 699   error (_("Profiling support is not available on this system."));
 700 }
 701 #endif
 702
 703 void
 704 _initialize_maint_cmds (void)
 705 {
 706   struct cmd_list_element *tmpcmd;
 707
 708   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
 709 Commands for use by GDB maintainers.\n\
 710 Includes commands to dump specific internal GDB structures in\n\
 711 a human readable form, to cause GDB to deliberately dump core,\n\
 712 to test internal functions such as the C++/ObjC demangler, etc."),
 713                   &maintenancelist, "maintenance ", 0,
 714                   &cmdlist);
 715
 716   add_com_alias ("mt", "maintenance", class_maintenance, 1);
 717
 718   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
 719 Commands for showing internal info about the program being debugged."),
 720                   &maintenanceinfolist, "maintenance info ", 0,
 721                   &maintenancelist);
 722   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
 723
 724   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
 725 List the BFD sections of the exec and core files. \n\
 726 Arguments may be any combination of:\n\
 727         [one or more section names]\n\
 728         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
 729         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
 730 Sections matching any argument will be listed (no argument\n\
 731 implies all sections).  In addition, the special argument\n\
 732         ALLOBJ\n\
 733 lists all sections from all object files, including shared libraries."),
 734            &maintenanceinfolist);
 735
 736   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
 737                   _("Maintenance command for printing GDB internal state."),
 738                   &maintenanceprintlist, "maintenance print ", 0,
 739                   &maintenancelist);
 740
 741   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
 742 Set GDB internal variables used by the GDB maintainer.\n\
 743 Configure variables internal to GDB that aid in GDB's maintenance"),
 744                   &maintenance_set_cmdlist, "maintenance set ",
 745                   0/*allow-unknown*/,
 746                   &maintenancelist);
 747
 748   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
 749 Show GDB internal variables used by the GDB maintainer.\n\
 750 Configure variables internal to GDB that aid in GDB's maintenance"),
 751                   &maintenance_show_cmdlist, "maintenance show ",
 752                   0/*allow-unknown*/,
 753                   &maintenancelist);
 754
 755 #ifndef _WIN32
 756   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
 757 Get fatal error; make debugger dump its core.\n\
 758 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
 759 itself a SIGQUIT signal."),
 760            &maintenancelist);
 761 #endif
 762
 763   add_cmd ("internal-error", class_maintenance,
 764            maintenance_internal_error, _("\
 765 Give GDB an internal error.\n\
 766 Cause GDB to behave as if an internal error was detected."),
 767            &maintenancelist);
 768
 769   add_cmd ("internal-warning", class_maintenance,
 770            maintenance_internal_warning, _("\
 771 Give GDB an internal warning.\n\
 772 Cause GDB to behave as if an internal warning was reported."),
 773            &maintenancelist);
 774
 775   add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
 776 Demangle a C++/ObjC mangled name.\n\
 777 Call internal GDB demangler routine to demangle a C++ link name\n\
 778 and prints the result."),
 779            &maintenancelist);
 780
 781   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
 782 Set the display of time usage.\n\
 783 If nonzero, will cause the execution time for each command to be\n\
 784 displayed, following the command's output."),
 785            &maintenancelist);
 786
 787   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
 788 Set the display of space usage.\n\
 789 If nonzero, will cause the execution space for each command to be\n\
 790 displayed, following the command's output."),
 791            &maintenancelist);
 792
 793   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
 794 Print a type chain for a given symbol.\n\
 795 For each node in a type chain, print the raw data for each member of\n\
 796 the type structure, and the interpretation of the data."),
 797            &maintenanceprintlist);
 798
 799   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
 800 Print dump of current symbol definitions.\n\
 801 Entries in the full symbol table are dumped to file OUTFILE.\n\
 802 If a SOURCE file is specified, dump only that file's symbols."),
 803            &maintenanceprintlist);
 804
 805   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
 806 Print dump of current minimal symbol definitions.\n\
 807 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
 808 If a SOURCE file is specified, dump only that file's minimal symbols."),
 809            &maintenanceprintlist);
 810
 811   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
 812 Print dump of current partial symbol definitions.\n\
 813 Entries in the partial symbol table are dumped to file OUTFILE.\n\
 814 If a SOURCE file is specified, dump only that file's partial symbols."),
 815            &maintenanceprintlist);
 816
 817   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
 818            _("Print dump of current object file definitions."),
 819            &maintenanceprintlist);
 820
 821   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
 822 List the full symbol tables for all object files.\n\
 823 This does not include information about individual symbols, blocks, or\n\
 824 linetables --- just the symbol table structures themselves.\n\
 825 With an argument REGEXP, list the symbol tables whose names that match that."),
 826            &maintenanceinfolist);
 827
 828   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
 829 List the partial symbol tables for all object files.\n\
 830 This does not include information about individual partial symbols,\n\
 831 just the symbol table structures themselves."),
 832            &maintenanceinfolist);
 833
 834   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
 835            _("Print statistics about internal gdb state."),
 836            &maintenanceprintlist);
 837
 838   add_cmd ("architecture", class_maintenance,
 839            maintenance_print_architecture, _("\
 840 Print the internal architecture configuration.\n\
 841 Takes an optional file parameter."),
 842            &maintenanceprintlist);
 843
 844   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
 845            _("Check consistency of psymtabs and symtabs."),
 846            &maintenancelist);
 847
 848   add_cmd ("translate-address", class_maintenance, maintenance_translate_address,
 849            _("Translate a section name and address to a symbol."),
 850            &maintenancelist);
 851
 852   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
 853 Deprecate a command.  Note that this is just in here so the \n\
 854 testsuite can check the comamnd deprecator. You probably shouldn't use this,\n\
 855 rather you should use the C function deprecate_cmd().  If you decide you \n\
 856 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
 857 replacement is optional."), &maintenancelist);
 858
 859   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
 860 Undeprecate a command.  Note that this is just in here so the \n\
 861 testsuite can check the comamnd deprecator. You probably shouldn't use this,\n\
 862 If you decide you want to use it: maintenance undeprecate 'commandname'"),
 863            &maintenancelist);
 864
 865   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
 866 Set watchdog timer."), _("\
 867 Show watchdog timer."), _("\
 868 When non-zero, this timeout is used instead of waiting forever for a target\n\
 869 to finish a low-level step or continue operation.  If the specified amount\n\
 870 of time passes without a response from the target, an error occurs."),
 871                             NULL,
 872                             show_watchdog,
 873                             &setlist, &showlist);
 874
 875   add_setshow_boolean_cmd ("profile", class_maintenance,
 876                            &maintenance_profile_p, _("\
 877 Set internal profiling."), _("\
 878 Show internal profiling."), _("\
 879 When enabled GDB is profiled."),
 880                            maintenance_set_profile_cmd,
 881                            show_maintenance_profile_p,
 882                            &maintenance_set_cmdlist,
 883                            &maintenance_show_cmdlist);
 884 }