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
 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
 501         = pulongest (address - SYMBOL_VALUE_ADDRESS (sym));
 502
 503       sect = SYMBOL_OBJ_SECTION(sym);
 504       if (sect != NULL)
 505         {
 506           const char *section_name;
 507           const char *obj_name;
 508
 509           gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
 510           section_name = sect->the_bfd_section->name;
 511
 512           gdb_assert (sect->objfile && sect->objfile->name);
 513           obj_name = sect->objfile->name;
 514
 515           if (MULTI_OBJFILE_P ())
 516             printf_filtered (_("%s + %s in section %s of %s\n"),
 517                              symbol_name, symbol_offset,
 518                              section_name, obj_name);
 519           else
 520             printf_filtered (_("%s + %s in section %s\n"),
 521                              symbol_name, symbol_offset, section_name);
 522         }
 523       else
 524         printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
 525     }
 526   else if (sect)
 527     printf_filtered (_("no symbol at %s:%s\n"),
 528                      sect->the_bfd_section->name, hex_string (address));
 529   else
 530     printf_filtered (_("no symbol at %s\n"), hex_string (address));
 531
 532   return;
 533 }
 534
 535
 536 /* When a command is deprecated the user will be warned the first time
 537    the command is used.  If possible, a replacement will be
 538    offered. */
 539
 540 static void
 541 maintenance_deprecate (char *args, int from_tty)
 542 {
 543   if (args == NULL || *args == '\0')
 544     {
 545       printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
 546 the command you want to deprecate, and optionally the replacement command\n\
 547 enclosed in quotes.\n"));
 548     }
 549
 550   maintenance_do_deprecate (args, 1);
 551
 552 }
 553
 554
 555 static void
 556 maintenance_undeprecate (char *args, int from_tty)
 557 {
 558   if (args == NULL || *args == '\0')
 559     {
 560       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 561 the command you want to undeprecate.\n"));
 562     }
 563
 564   maintenance_do_deprecate (args, 0);
 565
 566 }
 567
 568 /* You really shouldn't be using this. It is just for the testsuite.
 569    Rather, you should use deprecate_cmd() when the command is created
 570    in _initialize_blah().
 571
 572    This function deprecates a command and optionally assigns it a
 573    replacement.  */
 574
 575 static void
 576 maintenance_do_deprecate (char *text, int deprecate)
 577 {
 578   struct cmd_list_element *alias = NULL;
 579   struct cmd_list_element *prefix_cmd = NULL;
 580   struct cmd_list_element *cmd = NULL;
 581
 582   char *start_ptr = NULL;
 583   char *end_ptr = NULL;
 584   int len;
 585   char *replacement = NULL;
 586
 587   if (text == NULL)
 588     return;
 589
 590   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 591     {
 592       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 593       return;
 594     }
 595
 596   if (deprecate)
 597     {
 598       /* look for a replacement command */
 599       start_ptr = strchr (text, '\"');
 600       if (start_ptr != NULL)
 601         {
 602           start_ptr++;
 603           end_ptr = strrchr (start_ptr, '\"');
 604           if (end_ptr != NULL)
 605             {
 606               len = end_ptr - start_ptr;
 607               start_ptr[len] = '\0';
 608               replacement = xstrdup (start_ptr);
 609             }
 610         }
 611     }
 612
 613   if (!start_ptr || !end_ptr)
 614     replacement = NULL;
 615
 616
 617   /* If they used an alias, we only want to deprecate the alias.
 618
 619      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 620      string was allocated at compile time we don't want to free the
 621      memory. */
 622   if (alias)
 623     {
 624       if (alias->flags & MALLOCED_REPLACEMENT)
 625         xfree (alias->replacement);
 626
 627       if (deprecate)
 628         alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
 629       else
 630         alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
 631       alias->replacement = replacement;
 632       alias->flags |= MALLOCED_REPLACEMENT;
 633       return;
 634     }
 635   else if (cmd)
 636     {
 637       if (cmd->flags & MALLOCED_REPLACEMENT)
 638         xfree (cmd->replacement);
 639
 640       if (deprecate)
 641         cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
 642       else
 643         cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
 644       cmd->replacement = replacement;
 645       cmd->flags |= MALLOCED_REPLACEMENT;
 646       return;
 647     }
 648 }
 649
 650 /* Maintenance set/show framework.  */
 651
 652 struct cmd_list_element *maintenance_set_cmdlist;
 653 struct cmd_list_element *maintenance_show_cmdlist;
 654
 655 static void
 656 maintenance_set_cmd (char *args, int from_tty)
 657 {
 658   printf_unfiltered (_("\"maintenance set\" must be followed "
 659                        "by the name of a set command.\n"));
 660   help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
 661 }
 662
 663 static void
 664 maintenance_show_cmd (char *args, int from_tty)
 665 {
 666   cmd_show_list (maintenance_show_cmdlist, from_tty, "");
 667 }
 668
 669 /* Profiling support.  */
 670
 671 static int maintenance_profile_p;
 672 static void
 673 show_maintenance_profile_p (struct ui_file *file, int from_tty,
 674                             struct cmd_list_element *c, const char *value)
 675 {
 676   fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
 677 }
 678
 679 #ifdef HAVE__ETEXT
 680 extern char _etext;
 681 #define TEXTEND &_etext
 682 #elif defined (HAVE_ETEXT)
 683 extern char etext;
 684 #define TEXTEND &etext
 685 #endif
 686
 687 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
 688
 689 static int profiling_state;
 690
 691 static void
 692 mcleanup_wrapper (void)
 693 {
 694   extern void _mcleanup (void);
 695
 696   if (profiling_state)
 697     _mcleanup ();
 698 }
 699
 700 static void
 701 maintenance_set_profile_cmd (char *args, int from_tty,
 702                              struct cmd_list_element *c)
 703 {
 704   if (maintenance_profile_p == profiling_state)
 705     return;
 706
 707   profiling_state = maintenance_profile_p;
 708
 709   if (maintenance_profile_p)
 710     {
 711       static int profiling_initialized;
 712
 713       extern void monstartup (unsigned long, unsigned long);
 714       extern int main();
 715
 716       if (!profiling_initialized)
 717         {
 718           atexit (mcleanup_wrapper);
 719           profiling_initialized = 1;
 720         }
 721
 722       /* "main" is now always the first function in the text segment, so use
 723          its address for monstartup.  */
 724       monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
 725     }
 726   else
 727     {
 728       extern void _mcleanup (void);
 729
 730       _mcleanup ();
 731     }
 732 }
 733 #else
 734 static void
 735 maintenance_set_profile_cmd (char *args, int from_tty,
 736                              struct cmd_list_element *c)
 737 {
 738   error (_("Profiling support is not available on this system."));
 739 }
 740 #endif
 741
 742 void
 743 _initialize_maint_cmds (void)
 744 {
 745   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
 746 Commands for use by GDB maintainers.\n\
 747 Includes commands to dump specific internal GDB structures in\n\
 748 a human readable form, to cause GDB to deliberately dump core,\n\
 749 to test internal functions such as the C++/ObjC demangler, etc."),
 750                   &maintenancelist, "maintenance ", 0,
 751                   &cmdlist);
 752
 753   add_com_alias ("mt", "maintenance", class_maintenance, 1);
 754
 755   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
 756 Commands for showing internal info about the program being debugged."),
 757                   &maintenanceinfolist, "maintenance info ", 0,
 758                   &maintenancelist);
 759   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
 760
 761   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
 762 List the BFD sections of the exec and core files. \n\
 763 Arguments may be any combination of:\n\
 764         [one or more section names]\n\
 765         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
 766         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
 767 Sections matching any argument will be listed (no argument\n\
 768 implies all sections).  In addition, the special argument\n\
 769         ALLOBJ\n\
 770 lists all sections from all object files, including shared libraries."),
 771            &maintenanceinfolist);
 772
 773   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
 774                   _("Maintenance command for printing GDB internal state."),
 775                   &maintenanceprintlist, "maintenance print ", 0,
 776                   &maintenancelist);
 777
 778   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
 779 Set GDB internal variables used by the GDB maintainer.\n\
 780 Configure variables internal to GDB that aid in GDB's maintenance"),
 781                   &maintenance_set_cmdlist, "maintenance set ",
 782                   0/*allow-unknown*/,
 783                   &maintenancelist);
 784
 785   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
 786 Show GDB internal variables used by the GDB maintainer.\n\
 787 Configure variables internal to GDB that aid in GDB's maintenance"),
 788                   &maintenance_show_cmdlist, "maintenance show ",
 789                   0/*allow-unknown*/,
 790                   &maintenancelist);
 791
 792 #ifndef _WIN32
 793   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
 794 Get fatal error; make debugger dump its core.\n\
 795 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
 796 itself a SIGQUIT signal."),
 797            &maintenancelist);
 798 #endif
 799
 800   add_cmd ("internal-error", class_maintenance,
 801            maintenance_internal_error, _("\
 802 Give GDB an internal error.\n\
 803 Cause GDB to behave as if an internal error was detected."),
 804            &maintenancelist);
 805
 806   add_cmd ("internal-warning", class_maintenance,
 807            maintenance_internal_warning, _("\
 808 Give GDB an internal warning.\n\
 809 Cause GDB to behave as if an internal warning was reported."),
 810            &maintenancelist);
 811
 812   add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
 813 Demangle a C++/ObjC mangled name.\n\
 814 Call internal GDB demangler routine to demangle a C++ link name\n\
 815 and prints the result."),
 816            &maintenancelist);
 817
 818   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
 819 Set the display of time usage.\n\
 820 If nonzero, will cause the execution time for each command to be\n\
 821 displayed, following the command's output."),
 822            &maintenancelist);
 823
 824   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
 825 Set the display of space usage.\n\
 826 If nonzero, will cause the execution space for each command to be\n\
 827 displayed, following the command's output."),
 828            &maintenancelist);
 829
 830   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
 831 Print a type chain for a given symbol.\n\
 832 For each node in a type chain, print the raw data for each member of\n\
 833 the type structure, and the interpretation of the data."),
 834            &maintenanceprintlist);
 835
 836   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
 837 Print dump of current symbol definitions.\n\
 838 Entries in the full symbol table are dumped to file OUTFILE.\n\
 839 If a SOURCE file is specified, dump only that file's symbols."),
 840            &maintenanceprintlist);
 841
 842   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
 843 Print dump of current minimal symbol definitions.\n\
 844 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
 845 If a SOURCE file is specified, dump only that file's minimal symbols."),
 846            &maintenanceprintlist);
 847
 848   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
 849 Print dump of current partial symbol definitions.\n\
 850 Entries in the partial symbol table are dumped to file OUTFILE.\n\
 851 If a SOURCE file is specified, dump only that file's partial symbols."),
 852            &maintenanceprintlist);
 853
 854   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
 855            _("Print dump of current object file definitions."),
 856            &maintenanceprintlist);
 857
 858   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
 859 List the full symbol tables for all object files.\n\
 860 This does not include information about individual symbols, blocks, or\n\
 861 linetables --- just the symbol table structures themselves.\n\
 862 With an argument REGEXP, list the symbol tables whose names that match that."),
 863            &maintenanceinfolist);
 864
 865   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
 866 List the partial symbol tables for all object files.\n\
 867 This does not include information about individual partial symbols,\n\
 868 just the symbol table structures themselves."),
 869            &maintenanceinfolist);
 870
 871   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
 872            _("Print statistics about internal gdb state."),
 873            &maintenanceprintlist);
 874
 875   add_cmd ("architecture", class_maintenance,
 876            maintenance_print_architecture, _("\
 877 Print the internal architecture configuration.\n\
 878 Takes an optional file parameter."),
 879            &maintenanceprintlist);
 880
 881   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
 882            _("Check consistency of psymtabs and symtabs."),
 883            &maintenancelist);
 884
 885   add_cmd ("translate-address", class_maintenance,
 886            maintenance_translate_address,
 887            _("Translate a section name and address to a symbol."),
 888            &maintenancelist);
 889
 890   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
 891 Deprecate a command.  Note that this is just in here so the \n\
 892 testsuite can check the command deprecator. You probably shouldn't use this,\n\
 893 rather you should use the C function deprecate_cmd().  If you decide you \n\
 894 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
 895 replacement is optional."), &maintenancelist);
 896
 897   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
 898 Undeprecate a command.  Note that this is just in here so the \n\
 899 testsuite can check the command deprecator. You probably shouldn't use this,\n\
 900 If you decide you want to use it: maintenance undeprecate 'commandname'"),
 901            &maintenancelist);
 902
 903   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
 904 Set watchdog timer."), _("\
 905 Show watchdog timer."), _("\
 906 When non-zero, this timeout is used instead of waiting forever for a target\n\
 907 to finish a low-level step or continue operation.  If the specified amount\n\
 908 of time passes without a response from the target, an error occurs."),
 909                             NULL,
 910                             show_watchdog,
 911                             &setlist, &showlist);
 912
 913   add_setshow_boolean_cmd ("profile", class_maintenance,
 914                            &maintenance_profile_p, _("\
 915 Set internal profiling."), _("\
 916 Show internal profiling."), _("\
 917 When enabled GDB is profiled."),
 918                            maintenance_set_profile_cmd,
 919                            show_maintenance_profile_p,
 920                            &maintenance_set_cmdlist,
 921                            &maintenance_show_cmdlist);
 922 }