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