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 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       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       if (file == NULL)
 429         perror_with_name (_("maintenance print architecture"));
 430       cleanups = make_cleanup_ui_file_delete (file);
 431       gdbarch_dump (gdbarch, file);
 432       do_cleanups (cleanups);
 433     }
 434 }
 435
 436 /* The "maintenance print" command is defined as a prefix, with
 437    allow_unknown 0.  Therefore, its own definition is called only for
 438    "maintenance print" with no args.  */
 439
 440 static void
 441 maintenance_print_command (char *arg, int from_tty)
 442 {
 443   printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
 444   help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
 445 }
 446
 447 /* The "maintenance translate-address" command converts a section and address
 448    to a symbol.  This can be called in two ways:
 449    maintenance translate-address <secname> <addr>
 450    or   maintenance translate-address <addr>
 451  */
 452
 453 static void
 454 maintenance_translate_address (char *arg, int from_tty)
 455 {
 456   CORE_ADDR address;
 457   struct obj_section *sect;
 458   char *p;
 459   struct minimal_symbol *sym;
 460   struct objfile *objfile;
 461
 462   if (arg == NULL || *arg == 0)
 463     error (_("requires argument (address or section + address)"));
 464
 465   sect = NULL;
 466   p = arg;
 467
 468   if (!isdigit (*p))
 469     {                           /* See if we have a valid section name */
 470       while (*p && !isspace (*p))       /* Find end of section name */
 471         p++;
 472       if (*p == '\000')         /* End of command? */
 473         error (_("Need to specify <section-name> and <address>"));
 474       *p++ = '\000';
 475       while (isspace (*p))
 476         p++;                    /* Skip whitespace */
 477
 478       ALL_OBJSECTIONS (objfile, sect)
 479       {
 480         if (strcmp (sect->the_bfd_section->name, arg) == 0)
 481           break;
 482       }
 483
 484       if (!objfile)
 485         error (_("Unknown section %s."), arg);
 486     }
 487
 488   address = parse_and_eval_address (p);
 489
 490   if (sect)
 491     sym = lookup_minimal_symbol_by_pc_section (address, sect);
 492   else
 493     sym = lookup_minimal_symbol_by_pc (address);
 494
 495   if (sym)
 496     {
 497       const char *symbol_name = SYMBOL_PRINT_NAME (sym);
 498       const char *symbol_offset = pulongest (address - SYMBOL_VALUE_ADDRESS (sym));
 499
 500       sect = SYMBOL_OBJ_SECTION(sym);
 501       if (sect != NULL)
 502         {
 503           const char *section_name;
 504           const char *obj_name;
 505
 506           gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
 507           section_name = sect->the_bfd_section->name;
 508
 509           gdb_assert (sect->objfile && sect->objfile->name);
 510           obj_name = sect->objfile->name;
 511
 512           if (MULTI_OBJFILE_P ())
 513             printf_filtered (_("%s + %s in section %s of %s\n"),
 514                              symbol_name, symbol_offset, section_name, obj_name);
 515           else
 516             printf_filtered (_("%s + %s in section %s\n"),
 517                              symbol_name, symbol_offset, section_name);
 518         }
 519       else
 520         printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
 521     }
 522   else if (sect)
 523     printf_filtered (_("no symbol at %s:%s\n"),
 524                      sect->the_bfd_section->name, hex_string (address));
 525   else
 526     printf_filtered (_("no symbol at %s\n"), hex_string (address));
 527
 528   return;
 529 }
 530
 531
 532 /* When a command is deprecated the user will be warned the first time
 533    the command is used.  If possible, a replacement will be
 534    offered. */
 535
 536 static void
 537 maintenance_deprecate (char *args, int from_tty)
 538 {
 539   if (args == NULL || *args == '\0')
 540     {
 541       printf_unfiltered (_("\"maintenance deprecate\" takes an argument, \n\
 542 the command you want to deprecate, and optionally the replacement command \n\
 543 enclosed in quotes.\n"));
 544     }
 545
 546   maintenance_do_deprecate (args, 1);
 547
 548 }
 549
 550
 551 static void
 552 maintenance_undeprecate (char *args, int from_tty)
 553 {
 554   if (args == NULL || *args == '\0')
 555     {
 556       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 557 the command you want to undeprecate.\n"));
 558     }
 559
 560   maintenance_do_deprecate (args, 0);
 561
 562 }
 563
 564 /* You really shouldn't be using this. It is just for the testsuite.
 565    Rather, you should use deprecate_cmd() when the command is created
 566    in _initialize_blah().
 567
 568    This function deprecates a command and optionally assigns it a
 569    replacement.  */
 570
 571 static void
 572 maintenance_do_deprecate (char *text, int deprecate)
 573 {
 574
 575   struct cmd_list_element *alias = NULL;
 576   struct cmd_list_element *prefix_cmd = NULL;
 577   struct cmd_list_element *cmd = NULL;
 578
 579   char *start_ptr = NULL;
 580   char *end_ptr = NULL;
 581   int len;
 582   char *replacement = NULL;
 583
 584   if (text == NULL)
 585     return;
 586
 587   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 588     {
 589       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 590       return;
 591     }
 592
 593   if (deprecate)
 594     {
 595       /* look for a replacement command */
 596       start_ptr = strchr (text, '\"');
 597       if (start_ptr != NULL)
 598         {
 599           start_ptr++;
 600           end_ptr = strrchr (start_ptr, '\"');
 601           if (end_ptr != NULL)
 602             {
 603               len = end_ptr - start_ptr;
 604               start_ptr[len] = '\0';
 605               replacement = xstrdup (start_ptr);
 606             }
 607         }
 608     }
 609
 610   if (!start_ptr || !end_ptr)
 611     replacement = NULL;
 612
 613
 614   /* If they used an alias, we only want to deprecate the alias.
 615
 616      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 617      string was allocated at compile time we don't want to free the
 618      memory. */
 619   if (alias)
 620     {
 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       _mcleanup ();
 726     }
 727 }
 728 #else
 729 static void
 730 maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
 731 {
 732   error (_("Profiling support is not available on this system."));
 733 }
 734 #endif
 735
 736 void
 737 _initialize_maint_cmds (void)
 738 {
 739   struct cmd_list_element *tmpcmd;
 740
 741   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
 742 Commands for use by GDB maintainers.\n\
 743 Includes commands to dump specific internal GDB structures in\n\
 744 a human readable form, to cause GDB to deliberately dump core,\n\
 745 to test internal functions such as the C++/ObjC demangler, etc."),
 746                   &maintenancelist, "maintenance ", 0,
 747                   &cmdlist);
 748
 749   add_com_alias ("mt", "maintenance", class_maintenance, 1);
 750
 751   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
 752 Commands for showing internal info about the program being debugged."),
 753                   &maintenanceinfolist, "maintenance info ", 0,
 754                   &maintenancelist);
 755   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
 756
 757   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
 758 List the BFD sections of the exec and core files. \n\
 759 Arguments may be any combination of:\n\
 760         [one or more section names]\n\
 761         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
 762         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
 763 Sections matching any argument will be listed (no argument\n\
 764 implies all sections).  In addition, the special argument\n\
 765         ALLOBJ\n\
 766 lists all sections from all object files, including shared libraries."),
 767            &maintenanceinfolist);
 768
 769   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
 770                   _("Maintenance command for printing GDB internal state."),
 771                   &maintenanceprintlist, "maintenance print ", 0,
 772                   &maintenancelist);
 773
 774   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
 775 Set GDB internal variables used by the GDB maintainer.\n\
 776 Configure variables internal to GDB that aid in GDB's maintenance"),
 777                   &maintenance_set_cmdlist, "maintenance set ",
 778                   0/*allow-unknown*/,
 779                   &maintenancelist);
 780
 781   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
 782 Show GDB internal variables used by the GDB maintainer.\n\
 783 Configure variables internal to GDB that aid in GDB's maintenance"),
 784                   &maintenance_show_cmdlist, "maintenance show ",
 785                   0/*allow-unknown*/,
 786                   &maintenancelist);
 787
 788 #ifndef _WIN32
 789   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
 790 Get fatal error; make debugger dump its core.\n\
 791 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
 792 itself a SIGQUIT signal."),
 793            &maintenancelist);
 794 #endif
 795
 796   add_cmd ("internal-error", class_maintenance,
 797            maintenance_internal_error, _("\
 798 Give GDB an internal error.\n\
 799 Cause GDB to behave as if an internal error was detected."),
 800            &maintenancelist);
 801
 802   add_cmd ("internal-warning", class_maintenance,
 803            maintenance_internal_warning, _("\
 804 Give GDB an internal warning.\n\
 805 Cause GDB to behave as if an internal warning was reported."),
 806            &maintenancelist);
 807
 808   add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
 809 Demangle a C++/ObjC mangled name.\n\
 810 Call internal GDB demangler routine to demangle a C++ link name\n\
 811 and prints the result."),
 812            &maintenancelist);
 813
 814   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
 815 Set the display of time usage.\n\
 816 If nonzero, will cause the execution time for each command to be\n\
 817 displayed, following the command's output."),
 818            &maintenancelist);
 819
 820   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
 821 Set the display of space usage.\n\
 822 If nonzero, will cause the execution space for each command to be\n\
 823 displayed, following the command's output."),
 824            &maintenancelist);
 825
 826   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
 827 Print a type chain for a given symbol.\n\
 828 For each node in a type chain, print the raw data for each member of\n\
 829 the type structure, and the interpretation of the data."),
 830            &maintenanceprintlist);
 831
 832   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
 833 Print dump of current symbol definitions.\n\
 834 Entries in the full symbol table are dumped to file OUTFILE.\n\
 835 If a SOURCE file is specified, dump only that file's symbols."),
 836            &maintenanceprintlist);
 837
 838   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
 839 Print dump of current minimal symbol definitions.\n\
 840 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
 841 If a SOURCE file is specified, dump only that file's minimal symbols."),
 842            &maintenanceprintlist);
 843
 844   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
 845 Print dump of current partial symbol definitions.\n\
 846 Entries in the partial symbol table are dumped to file OUTFILE.\n\
 847 If a SOURCE file is specified, dump only that file's partial symbols."),
 848            &maintenanceprintlist);
 849
 850   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
 851            _("Print dump of current object file definitions."),
 852            &maintenanceprintlist);
 853
 854   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
 855 List the full symbol tables for all object files.\n\
 856 This does not include information about individual symbols, blocks, or\n\
 857 linetables --- just the symbol table structures themselves.\n\
 858 With an argument REGEXP, list the symbol tables whose names that match that."),
 859            &maintenanceinfolist);
 860
 861   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
 862 List the partial symbol tables for all object files.\n\
 863 This does not include information about individual partial symbols,\n\
 864 just the symbol table structures themselves."),
 865            &maintenanceinfolist);
 866
 867   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
 868            _("Print statistics about internal gdb state."),
 869            &maintenanceprintlist);
 870
 871   add_cmd ("architecture", class_maintenance,
 872            maintenance_print_architecture, _("\
 873 Print the internal architecture configuration.\n\
 874 Takes an optional file parameter."),
 875            &maintenanceprintlist);
 876
 877   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
 878            _("Check consistency of psymtabs and symtabs."),
 879            &maintenancelist);
 880
 881   add_cmd ("translate-address", class_maintenance, maintenance_translate_address,
 882            _("Translate a section name and address to a symbol."),
 883            &maintenancelist);
 884
 885   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
 886 Deprecate a command.  Note that this is just in here so the \n\
 887 testsuite can check the command deprecator. You probably shouldn't use this,\n\
 888 rather you should use the C function deprecate_cmd().  If you decide you \n\
 889 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
 890 replacement is optional."), &maintenancelist);
 891
 892   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
 893 Undeprecate a command.  Note that this is just in here so the \n\
 894 testsuite can check the command deprecator. You probably shouldn't use this,\n\
 895 If you decide you want to use it: maintenance undeprecate 'commandname'"),
 896            &maintenancelist);
 897
 898   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
 899 Set watchdog timer."), _("\
 900 Show watchdog timer."), _("\
 901 When non-zero, this timeout is used instead of waiting forever for a target\n\
 902 to finish a low-level step or continue operation.  If the specified amount\n\
 903 of time passes without a response from the target, an error occurs."),
 904                             NULL,
 905                             show_watchdog,
 906                             &setlist, &showlist);
 907
 908   add_setshow_boolean_cmd ("profile", class_maintenance,
 909                            &maintenance_profile_p, _("\
 910 Set internal profiling."), _("\
 911 Show internal profiling."), _("\
 912 When enabled GDB is profiled."),
 913                            maintenance_set_profile_cmd,
 914                            show_maintenance_profile_p,
 915                            &maintenance_set_cmdlist,
 916                            &maintenance_show_cmdlist);
 917 }