gdb/maint.c

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