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