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, 2010 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   if (args == NULL || *args == '\0')
 175     printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
 176   else
 177     set_display_time (strtol (args, NULL, 10));
 178 }
 179
 180 static void
 181 maintenance_space_display (char *args, int from_tty)
 182 {
 183   if (args == NULL || *args == '\0')
 184     printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
 185   else
 186     set_display_space (strtol (args, NULL, 10));
 187 }
 188
 189 /* The "maintenance info" command is defined as a prefix, with
 190    allow_unknown 0.  Therefore, its own definition is called only for
 191    "maintenance info" with no args.  */
 192
 193 static void
 194 maintenance_info_command (char *arg, int from_tty)
 195 {
 196   printf_unfiltered (_("\"maintenance info\" must be followed by the name of an info command.\n"));
 197   help_list (maintenanceinfolist, "maintenance info ", -1, gdb_stdout);
 198 }
 199
 200 /* Mini tokenizing lexer for 'maint info sections' command.  */
 201
 202 static int
 203 match_substring (const char *string, const char *substr)
 204 {
 205   int substr_len = strlen(substr);
 206   const char *tok;
 207
 208   while ((tok = strstr (string, substr)) != NULL)
 209     {
 210       /* Got a partial match.  Is it a whole word? */
 211       if (tok == string
 212           || tok[-1] == ' '
 213           || tok[-1] == '\t')
 214       {
 215         /* Token is delimited at the front... */
 216         if (tok[substr_len] == ' '
 217             || tok[substr_len] == '\t'
 218             || tok[substr_len] == '\0')
 219         {
 220           /* Token is delimited at the rear.  Got a whole-word match.  */
 221           return 1;
 222         }
 223       }
 224       /* Token didn't match as a whole word.  Advance and try again.  */
 225       string = tok + 1;
 226     }
 227   return 0;
 228 }
 229
 230 static int
 231 match_bfd_flags (char *string, flagword flags)
 232 {
 233   if (flags & SEC_ALLOC)
 234     if (match_substring (string, "ALLOC"))
 235       return 1;
 236   if (flags & SEC_LOAD)
 237     if (match_substring (string, "LOAD"))
 238       return 1;
 239   if (flags & SEC_RELOC)
 240     if (match_substring (string, "RELOC"))
 241       return 1;
 242   if (flags & SEC_READONLY)
 243     if (match_substring (string, "READONLY"))
 244       return 1;
 245   if (flags & SEC_CODE)
 246     if (match_substring (string, "CODE"))
 247       return 1;
 248   if (flags & SEC_DATA)
 249     if (match_substring (string, "DATA"))
 250       return 1;
 251   if (flags & SEC_ROM)
 252     if (match_substring (string, "ROM"))
 253       return 1;
 254   if (flags & SEC_CONSTRUCTOR)
 255     if (match_substring (string, "CONSTRUCTOR"))
 256       return 1;
 257   if (flags & SEC_HAS_CONTENTS)
 258     if (match_substring (string, "HAS_CONTENTS"))
 259       return 1;
 260   if (flags & SEC_NEVER_LOAD)
 261     if (match_substring (string, "NEVER_LOAD"))
 262       return 1;
 263   if (flags & SEC_COFF_SHARED_LIBRARY)
 264     if (match_substring (string, "COFF_SHARED_LIBRARY"))
 265       return 1;
 266   if (flags & SEC_IS_COMMON)
 267     if (match_substring (string, "IS_COMMON"))
 268       return 1;
 269
 270   return 0;
 271 }
 272
 273 static void
 274 print_bfd_flags (flagword flags)
 275 {
 276   if (flags & SEC_ALLOC)
 277     printf_filtered (" ALLOC");
 278   if (flags & SEC_LOAD)
 279     printf_filtered (" LOAD");
 280   if (flags & SEC_RELOC)
 281     printf_filtered (" RELOC");
 282   if (flags & SEC_READONLY)
 283     printf_filtered (" READONLY");
 284   if (flags & SEC_CODE)
 285     printf_filtered (" CODE");
 286   if (flags & SEC_DATA)
 287     printf_filtered (" DATA");
 288   if (flags & SEC_ROM)
 289     printf_filtered (" ROM");
 290   if (flags & SEC_CONSTRUCTOR)
 291     printf_filtered (" CONSTRUCTOR");
 292   if (flags & SEC_HAS_CONTENTS)
 293     printf_filtered (" HAS_CONTENTS");
 294   if (flags & SEC_NEVER_LOAD)
 295     printf_filtered (" NEVER_LOAD");
 296   if (flags & SEC_COFF_SHARED_LIBRARY)
 297     printf_filtered (" COFF_SHARED_LIBRARY");
 298   if (flags & SEC_IS_COMMON)
 299     printf_filtered (" IS_COMMON");
 300 }
 301
 302 static void
 303 maint_print_section_info (const char *name, flagword flags,
 304                           CORE_ADDR addr, CORE_ADDR endaddr,
 305                           unsigned long filepos, int addr_size)
 306 {
 307   printf_filtered ("    %s", hex_string_custom (addr, addr_size));
 308   printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
 309   printf_filtered (" at %s",
 310                    hex_string_custom ((unsigned long) filepos, 8));
 311   printf_filtered (": %s", name);
 312   print_bfd_flags (flags);
 313   printf_filtered ("\n");
 314 }
 315
 316 static void
 317 print_bfd_section_info (bfd *abfd,
 318                         asection *asect,
 319                         void *arg)
 320 {
 321   flagword flags = bfd_get_section_flags (abfd, asect);
 322   const char *name = bfd_section_name (abfd, asect);
 323
 324   if (arg == NULL || *((char *) arg) == '\0'
 325       || match_substring ((char *) arg, name)
 326       || match_bfd_flags ((char *) arg, flags))
 327     {
 328       struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 329       int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 330       CORE_ADDR addr, endaddr;
 331
 332       addr = bfd_section_vma (abfd, asect);
 333       endaddr = addr + bfd_section_size (abfd, asect);
 334       maint_print_section_info (name, flags, addr, endaddr,
 335                                 asect->filepos, addr_size);
 336     }
 337 }
 338
 339 static void
 340 print_objfile_section_info (bfd *abfd,
 341                             struct obj_section *asect,
 342                             char *string)
 343 {
 344   flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
 345   const char *name = bfd_section_name (abfd, asect->the_bfd_section);
 346
 347   if (string == NULL || *string == '\0'
 348       || match_substring (string, name)
 349       || match_bfd_flags (string, flags))
 350     {
 351       struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 352       int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 353
 354       maint_print_section_info (name, flags,
 355                                 obj_section_addr (asect),
 356                                 obj_section_endaddr (asect),
 357                                 asect->the_bfd_section->filepos,
 358                                 addr_size);
 359     }
 360 }
 361
 362 static void
 363 maintenance_info_sections (char *arg, int from_tty)
 364 {
 365   if (exec_bfd)
 366     {
 367       printf_filtered (_("Exec file:\n"));
 368       printf_filtered ("    `%s', ", bfd_get_filename (exec_bfd));
 369       wrap_here ("        ");
 370       printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
 371       if (arg && *arg && match_substring (arg, "ALLOBJ"))
 372         {
 373           struct objfile *ofile;
 374           struct obj_section *osect;
 375
 376           /* Only this function cares about the 'ALLOBJ' argument;
 377              if 'ALLOBJ' is the only argument, discard it rather than
 378              passing it down to print_objfile_section_info (which
 379              wouldn't know how to handle it).  */
 380           if (strcmp (arg, "ALLOBJ") == 0)
 381             arg = NULL;
 382
 383           ALL_OBJFILES (ofile)
 384             {
 385               printf_filtered (_("  Object file: %s\n"),
 386                                bfd_get_filename (ofile->obfd));
 387               ALL_OBJFILE_OSECTIONS (ofile, osect)
 388                 {
 389                   print_objfile_section_info (ofile->obfd, osect, arg);
 390                 }
 391             }
 392         }
 393       else
 394         bfd_map_over_sections (exec_bfd, print_bfd_section_info, arg);
 395     }
 396
 397   if (core_bfd)
 398     {
 399       printf_filtered (_("Core file:\n"));
 400       printf_filtered ("    `%s', ", bfd_get_filename (core_bfd));
 401       wrap_here ("        ");
 402       printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
 403       bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
 404     }
 405 }
 406
 407 void
 408 maintenance_print_statistics (char *args, int from_tty)
 409 {
 410   print_objfile_statistics ();
 411   print_symbol_bcache_statistics ();
 412 }
 413
 414 static void
 415 maintenance_print_architecture (char *args, int from_tty)
 416 {
 417   struct gdbarch *gdbarch = get_current_arch ();
 418
 419   if (args == NULL)
 420     gdbarch_dump (gdbarch, gdb_stdout);
 421   else
 422     {
 423       struct cleanup *cleanups;
 424       struct ui_file *file = gdb_fopen (args, "w");
 425
 426       if (file == NULL)
 427         perror_with_name (_("maintenance print architecture"));
 428       cleanups = make_cleanup_ui_file_delete (file);
 429       gdbarch_dump (gdbarch, file);
 430       do_cleanups (cleanups);
 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 static void
 439 maintenance_print_command (char *arg, int from_tty)
 440 {
 441   printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
 442   help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
 443 }
 444
 445 /* The "maintenance translate-address" command converts a section and address
 446    to a symbol.  This can be called in two ways:
 447    maintenance translate-address <secname> <addr>
 448    or   maintenance translate-address <addr>
 449  */
 450
 451 static void
 452 maintenance_translate_address (char *arg, int from_tty)
 453 {
 454   CORE_ADDR address;
 455   struct obj_section *sect;
 456   char *p;
 457   struct minimal_symbol *sym;
 458   struct objfile *objfile;
 459
 460   if (arg == NULL || *arg == 0)
 461     error (_("requires argument (address or section + address)"));
 462
 463   sect = NULL;
 464   p = arg;
 465
 466   if (!isdigit (*p))
 467     {                           /* See if we have a valid section name */
 468       while (*p && !isspace (*p))       /* Find end of section name */
 469         p++;
 470       if (*p == '\000')         /* End of command? */
 471         error (_("Need to specify <section-name> and <address>"));
 472       *p++ = '\000';
 473       while (isspace (*p))
 474         p++;                    /* Skip whitespace */
 475
 476       ALL_OBJSECTIONS (objfile, sect)
 477       {
 478         if (strcmp (sect->the_bfd_section->name, arg) == 0)
 479           break;
 480       }
 481
 482       if (!objfile)
 483         error (_("Unknown section %s."), arg);
 484     }
 485
 486   address = parse_and_eval_address (p);
 487
 488   if (sect)
 489     sym = lookup_minimal_symbol_by_pc_section (address, sect);
 490   else
 491     sym = lookup_minimal_symbol_by_pc (address);
 492
 493   if (sym)
 494     {
 495       const char *symbol_name = SYMBOL_PRINT_NAME (sym);
 496       const char *symbol_offset = pulongest (address - SYMBOL_VALUE_ADDRESS (sym));
 497
 498       sect = SYMBOL_OBJ_SECTION(sym);
 499       if (sect != NULL)
 500         {
 501           const char *section_name;
 502           const char *obj_name;
 503
 504           gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
 505           section_name = sect->the_bfd_section->name;
 506
 507           gdb_assert (sect->objfile && sect->objfile->name);
 508           obj_name = sect->objfile->name;
 509
 510           if (MULTI_OBJFILE_P ())
 511             printf_filtered (_("%s + %s in section %s of %s\n"),
 512                              symbol_name, symbol_offset, section_name, obj_name);
 513           else
 514             printf_filtered (_("%s + %s in section %s\n"),
 515                              symbol_name, symbol_offset, section_name);
 516         }
 517       else
 518         printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
 519     }
 520   else if (sect)
 521     printf_filtered (_("no symbol at %s:%s\n"),
 522                      sect->the_bfd_section->name, hex_string (address));
 523   else
 524     printf_filtered (_("no symbol at %s\n"), hex_string (address));
 525
 526   return;
 527 }
 528
 529
 530 /* When a command is deprecated the user will be warned the first time
 531    the command is used.  If possible, a replacement will be
 532    offered. */
 533
 534 static void
 535 maintenance_deprecate (char *args, int from_tty)
 536 {
 537   if (args == NULL || *args == '\0')
 538     {
 539       printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
 540 the command you want to deprecate, and optionally the replacement command\n\
 541 enclosed in quotes.\n"));
 542     }
 543
 544   maintenance_do_deprecate (args, 1);
 545
 546 }
 547
 548
 549 static void
 550 maintenance_undeprecate (char *args, int from_tty)
 551 {
 552   if (args == NULL || *args == '\0')
 553     {
 554       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 555 the command you want to undeprecate.\n"));
 556     }
 557
 558   maintenance_do_deprecate (args, 0);
 559
 560 }
 561
 562 /* You really shouldn't be using this. It is just for the testsuite.
 563    Rather, you should use deprecate_cmd() when the command is created
 564    in _initialize_blah().
 565
 566    This function deprecates a command and optionally assigns it a
 567    replacement.  */
 568
 569 static void
 570 maintenance_do_deprecate (char *text, int deprecate)
 571 {
 572   struct cmd_list_element *alias = NULL;
 573   struct cmd_list_element *prefix_cmd = NULL;
 574   struct cmd_list_element *cmd = NULL;
 575
 576   char *start_ptr = NULL;
 577   char *end_ptr = NULL;
 578   int len;
 579   char *replacement = NULL;
 580
 581   if (text == NULL)
 582     return;
 583
 584   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 585     {
 586       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 587       return;
 588     }
 589
 590   if (deprecate)
 591     {
 592       /* look for a replacement command */
 593       start_ptr = strchr (text, '\"');
 594       if (start_ptr != NULL)
 595         {
 596           start_ptr++;
 597           end_ptr = strrchr (start_ptr, '\"');
 598           if (end_ptr != NULL)
 599             {
 600               len = end_ptr - start_ptr;
 601               start_ptr[len] = '\0';
 602               replacement = xstrdup (start_ptr);
 603             }
 604         }
 605     }
 606
 607   if (!start_ptr || !end_ptr)
 608     replacement = NULL;
 609
 610
 611   /* If they used an alias, we only want to deprecate the alias.
 612
 613      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 614      string was allocated at compile time we don't want to free the
 615      memory. */
 616   if (alias)
 617     {
 618       if (alias->flags & MALLOCED_REPLACEMENT)
 619         xfree (alias->replacement);
 620
 621       if (deprecate)
 622         alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
 623       else
 624         alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
 625       alias->replacement = replacement;
 626       alias->flags |= MALLOCED_REPLACEMENT;
 627       return;
 628     }
 629   else if (cmd)
 630     {
 631       if (cmd->flags & MALLOCED_REPLACEMENT)
 632         xfree (cmd->replacement);
 633
 634       if (deprecate)
 635         cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
 636       else
 637         cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
 638       cmd->replacement = replacement;
 639       cmd->flags |= MALLOCED_REPLACEMENT;
 640       return;
 641     }
 642 }
 643
 644 /* Maintenance set/show framework.  */
 645
 646 struct cmd_list_element *maintenance_set_cmdlist;
 647 struct cmd_list_element *maintenance_show_cmdlist;
 648
 649 static void
 650 maintenance_set_cmd (char *args, int from_tty)
 651 {
 652   printf_unfiltered (_("\"maintenance set\" must be followed by the name of a set command.\n"));
 653   help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
 654 }
 655
 656 static void
 657 maintenance_show_cmd (char *args, int from_tty)
 658 {
 659   cmd_show_list (maintenance_show_cmdlist, from_tty, "");
 660 }
 661
 662 /* Profiling support.  */
 663
 664 static int maintenance_profile_p;
 665 static void
 666 show_maintenance_profile_p (struct ui_file *file, int from_tty,
 667                             struct cmd_list_element *c, const char *value)
 668 {
 669   fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
 670 }
 671
 672 #ifdef HAVE__ETEXT
 673 extern char _etext;
 674 #define TEXTEND &_etext
 675 #elif defined (HAVE_ETEXT)
 676 extern char etext;
 677 #define TEXTEND &etext
 678 #endif
 679
 680 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
 681
 682 static int profiling_state;
 683
 684 static void
 685 mcleanup_wrapper (void)
 686 {
 687   extern void _mcleanup (void);
 688
 689   if (profiling_state)
 690     _mcleanup ();
 691 }
 692
 693 static void
 694 maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
 695 {
 696   if (maintenance_profile_p == profiling_state)
 697     return;
 698
 699   profiling_state = maintenance_profile_p;
 700
 701   if (maintenance_profile_p)
 702     {
 703       static int profiling_initialized;
 704
 705       extern void monstartup (unsigned long, unsigned long);
 706       extern int main();
 707
 708       if (!profiling_initialized)
 709         {
 710           atexit (mcleanup_wrapper);
 711           profiling_initialized = 1;
 712         }
 713
 714       /* "main" is now always the first function in the text segment, so use
 715          its address for monstartup.  */
 716       monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
 717     }
 718   else
 719     {
 720       extern void _mcleanup (void);
 721
 722       _mcleanup ();
 723     }
 724 }
 725 #else
 726 static void
 727 maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
 728 {
 729   error (_("Profiling support is not available on this system."));
 730 }
 731 #endif
 732
 733 void
 734 _initialize_maint_cmds (void)
 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 }