gdb/maint.c

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