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