gdb/maint.c

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