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