gdb/maint.c

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