gdb/maint.c

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