gdb/maint.c

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