gdb/maint.c

   1 /* Support for GDB maintenance commands.
   2
   3    Copyright (C) 1992-2016 Free Software Foundation, Inc.
   4
   5    Written by Fred Fish at Cygnus Support.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "defs.h"
  24 #include "arch-utils.h"
  25 #include <ctype.h>
  26 #include <signal.h>
  27 #include "gdb_sys_time.h"
  28 #include <time.h>
  29 #include "command.h"
  30 #include "gdbcmd.h"
  31 #include "symtab.h"
  32 #include "block.h"
  33 #include "gdbtypes.h"
  34 #include "demangle.h"
  35 #include "gdbcore.h"
  36 #include "expression.h"         /* For language.h */
  37 #include "language.h"
  38 #include "symfile.h"
  39 #include "objfiles.h"
  40 #include "value.h"
  41 #include "top.h"
  42 #include "timeval-utils.h"
  43 #include "maint.h"
  44 #include "selftest.h"
  45
  46 #include "cli/cli-decode.h"
  47 #include "cli/cli-utils.h"
  48 #include "cli/cli-setshow.h"
  49
  50 extern void _initialize_maint_cmds (void);
  51
  52 static void maintenance_command (char *, int);
  53
  54 static void maintenance_internal_error (char *args, int from_tty);
  55
  56 static void maintenance_demangle (char *, int);
  57
  58 static void maintenance_time_display (char *, int);
  59
  60 static void maintenance_space_display (char *, int);
  61
  62 static void maintenance_info_command (char *, int);
  63
  64 static void maintenance_info_sections (char *, int);
  65
  66 static void maintenance_print_command (char *, int);
  67
  68 static void maintenance_do_deprecate (char *, int);
  69
  70 /* Set this to the maximum number of seconds to wait instead of waiting forever
  71    in target_wait().  If this timer times out, then it generates an error and
  72    the command is aborted.  This replaces most of the need for timeouts in the
  73    GDB test suite, and makes it possible to distinguish between a hung target
  74    and one with slow communications.  */
  75
  76 int watchdog = 0;
  77 static void
  78 show_watchdog (struct ui_file *file, int from_tty,
  79                struct cmd_list_element *c, const char *value)
  80 {
  81   fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
  82 }
  83
  84 /* Access the maintenance subcommands.  */
  85
  86 static void
  87 maintenance_command (char *args, int from_tty)
  88 {
  89   printf_unfiltered (_("\"maintenance\" must be followed by "
  90                        "the name of a maintenance command.\n"));
  91   help_list (maintenancelist, "maintenance ", all_commands, gdb_stdout);
  92 }
  93
  94 #ifndef _WIN32
  95 static void
  96 maintenance_dump_me (char *args, int from_tty)
  97 {
  98   if (query (_("Should GDB dump core? ")))
  99     {
 100 #ifdef __DJGPP__
 101       /* SIGQUIT by default is ignored, so use SIGABRT instead.  */
 102       signal (SIGABRT, SIG_DFL);
 103       kill (getpid (), SIGABRT);
 104 #else
 105       signal (SIGQUIT, SIG_DFL);
 106       kill (getpid (), SIGQUIT);
 107 #endif
 108     }
 109 }
 110 #endif
 111
 112 /* Stimulate the internal error mechanism that GDB uses when an
 113    internal problem is detected.  Allows testing of the mechanism.
 114    Also useful when the user wants to drop a core file but not exit
 115    GDB.  */
 116
 117 static void
 118 maintenance_internal_error (char *args, int from_tty)
 119 {
 120   internal_error (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
 121 }
 122
 123 /* Stimulate the internal error mechanism that GDB uses when an
 124    internal problem is detected.  Allows testing of the mechanism.
 125    Also useful when the user wants to drop a core file but not exit
 126    GDB.  */
 127
 128 static void
 129 maintenance_internal_warning (char *args, int from_tty)
 130 {
 131   internal_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
 132 }
 133
 134 /* Stimulate the internal error mechanism that GDB uses when an
 135    demangler problem is detected.  Allows testing of the mechanism.  */
 136
 137 static void
 138 maintenance_demangler_warning (char *args, int from_tty)
 139 {
 140   demangler_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
 141 }
 142
 143 /* Old command to demangle a string.  The command has been moved to "demangle".
 144    It is kept for now because otherwise "mt demangle" gets interpreted as
 145    "mt demangler-warning" which artificially creates an internal gdb error.  */
 146
 147 static void
 148 maintenance_demangle (char *args, int from_tty)
 149 {
 150   printf_filtered (_("This command has been moved to \"demangle\".\n"));
 151 }
 152
 153 static void
 154 maintenance_time_display (char *args, int from_tty)
 155 {
 156   if (args == NULL || *args == '\0')
 157     printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
 158   else
 159     set_per_command_time (strtol (args, NULL, 10));
 160 }
 161
 162 static void
 163 maintenance_space_display (char *args, int from_tty)
 164 {
 165   if (args == NULL || *args == '\0')
 166     printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
 167   else
 168     set_per_command_space (strtol (args, NULL, 10));
 169 }
 170
 171 /* The "maintenance info" command is defined as a prefix, with
 172    allow_unknown 0.  Therefore, its own definition is called only for
 173    "maintenance info" with no args.  */
 174
 175 static void
 176 maintenance_info_command (char *arg, int from_tty)
 177 {
 178   printf_unfiltered (_("\"maintenance info\" must be followed "
 179                        "by the name of an info command.\n"));
 180   help_list (maintenanceinfolist, "maintenance info ", all_commands,
 181              gdb_stdout);
 182 }
 183
 184 /* Mini tokenizing lexer for 'maint info sections' command.  */
 185
 186 static int
 187 match_substring (const char *string, const char *substr)
 188 {
 189   int substr_len = strlen(substr);
 190   const char *tok;
 191
 192   while ((tok = strstr (string, substr)) != NULL)
 193     {
 194       /* Got a partial match.  Is it a whole word?  */
 195       if (tok == string
 196           || tok[-1] == ' '
 197           || tok[-1] == '\t')
 198       {
 199         /* Token is delimited at the front...  */
 200         if (tok[substr_len] == ' '
 201             || tok[substr_len] == '\t'
 202             || tok[substr_len] == '\0')
 203         {
 204           /* Token is delimited at the rear.  Got a whole-word match.  */
 205           return 1;
 206         }
 207       }
 208       /* Token didn't match as a whole word.  Advance and try again.  */
 209       string = tok + 1;
 210     }
 211   return 0;
 212 }
 213
 214 static int
 215 match_bfd_flags (const char *string, flagword flags)
 216 {
 217   if (flags & SEC_ALLOC)
 218     if (match_substring (string, "ALLOC"))
 219       return 1;
 220   if (flags & SEC_LOAD)
 221     if (match_substring (string, "LOAD"))
 222       return 1;
 223   if (flags & SEC_RELOC)
 224     if (match_substring (string, "RELOC"))
 225       return 1;
 226   if (flags & SEC_READONLY)
 227     if (match_substring (string, "READONLY"))
 228       return 1;
 229   if (flags & SEC_CODE)
 230     if (match_substring (string, "CODE"))
 231       return 1;
 232   if (flags & SEC_DATA)
 233     if (match_substring (string, "DATA"))
 234       return 1;
 235   if (flags & SEC_ROM)
 236     if (match_substring (string, "ROM"))
 237       return 1;
 238   if (flags & SEC_CONSTRUCTOR)
 239     if (match_substring (string, "CONSTRUCTOR"))
 240       return 1;
 241   if (flags & SEC_HAS_CONTENTS)
 242     if (match_substring (string, "HAS_CONTENTS"))
 243       return 1;
 244   if (flags & SEC_NEVER_LOAD)
 245     if (match_substring (string, "NEVER_LOAD"))
 246       return 1;
 247   if (flags & SEC_COFF_SHARED_LIBRARY)
 248     if (match_substring (string, "COFF_SHARED_LIBRARY"))
 249       return 1;
 250   if (flags & SEC_IS_COMMON)
 251     if (match_substring (string, "IS_COMMON"))
 252       return 1;
 253
 254   return 0;
 255 }
 256
 257 static void
 258 print_bfd_flags (flagword flags)
 259 {
 260   if (flags & SEC_ALLOC)
 261     printf_filtered (" ALLOC");
 262   if (flags & SEC_LOAD)
 263     printf_filtered (" LOAD");
 264   if (flags & SEC_RELOC)
 265     printf_filtered (" RELOC");
 266   if (flags & SEC_READONLY)
 267     printf_filtered (" READONLY");
 268   if (flags & SEC_CODE)
 269     printf_filtered (" CODE");
 270   if (flags & SEC_DATA)
 271     printf_filtered (" DATA");
 272   if (flags & SEC_ROM)
 273     printf_filtered (" ROM");
 274   if (flags & SEC_CONSTRUCTOR)
 275     printf_filtered (" CONSTRUCTOR");
 276   if (flags & SEC_HAS_CONTENTS)
 277     printf_filtered (" HAS_CONTENTS");
 278   if (flags & SEC_NEVER_LOAD)
 279     printf_filtered (" NEVER_LOAD");
 280   if (flags & SEC_COFF_SHARED_LIBRARY)
 281     printf_filtered (" COFF_SHARED_LIBRARY");
 282   if (flags & SEC_IS_COMMON)
 283     printf_filtered (" IS_COMMON");
 284 }
 285
 286 static void
 287 maint_print_section_info (const char *name, flagword flags,
 288                           CORE_ADDR addr, CORE_ADDR endaddr,
 289                           unsigned long filepos, int addr_size)
 290 {
 291   printf_filtered ("    %s", hex_string_custom (addr, addr_size));
 292   printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
 293   printf_filtered (" at %s",
 294                    hex_string_custom ((unsigned long) filepos, 8));
 295   printf_filtered (": %s", name);
 296   print_bfd_flags (flags);
 297   printf_filtered ("\n");
 298 }
 299
 300 static void
 301 print_bfd_section_info (bfd *abfd,
 302                         asection *asect,
 303                         void *datum)
 304 {
 305   flagword flags = bfd_get_section_flags (abfd, asect);
 306   const char *name = bfd_section_name (abfd, asect);
 307   const char *arg = (const char *) datum;
 308
 309   if (arg == NULL || *arg == '\0'
 310       || match_substring (arg, name)
 311       || match_bfd_flags (arg, flags))
 312     {
 313       struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 314       int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 315       CORE_ADDR addr, endaddr;
 316
 317       addr = bfd_section_vma (abfd, asect);
 318       endaddr = addr + bfd_section_size (abfd, asect);
 319       printf_filtered (" [%d] ", gdb_bfd_section_index (abfd, asect));
 320       maint_print_section_info (name, flags, addr, endaddr,
 321                                 asect->filepos, addr_size);
 322     }
 323 }
 324
 325 static void
 326 print_objfile_section_info (bfd *abfd,
 327                             struct obj_section *asect,
 328                             const char *string)
 329 {
 330   flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
 331   const char *name = bfd_section_name (abfd, asect->the_bfd_section);
 332
 333   if (string == NULL || *string == '\0'
 334       || match_substring (string, name)
 335       || match_bfd_flags (string, flags))
 336     {
 337       struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 338       int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 339
 340       maint_print_section_info (name, flags,
 341                                 obj_section_addr (asect),
 342                                 obj_section_endaddr (asect),
 343                                 asect->the_bfd_section->filepos,
 344                                 addr_size);
 345     }
 346 }
 347
 348 static void
 349 maintenance_info_sections (char *arg, int from_tty)
 350 {
 351   if (exec_bfd)
 352     {
 353       printf_filtered (_("Exec file:\n"));
 354       printf_filtered ("    `%s', ", bfd_get_filename (exec_bfd));
 355       wrap_here ("        ");
 356       printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
 357       if (arg && *arg && match_substring (arg, "ALLOBJ"))
 358         {
 359           struct objfile *ofile;
 360           struct obj_section *osect;
 361
 362           /* Only this function cares about the 'ALLOBJ' argument;
 363              if 'ALLOBJ' is the only argument, discard it rather than
 364              passing it down to print_objfile_section_info (which
 365              wouldn't know how to handle it).  */
 366           if (strcmp (arg, "ALLOBJ") == 0)
 367             arg = NULL;
 368
 369           ALL_OBJFILES (ofile)
 370             {
 371               printf_filtered (_("  Object file: %s\n"),
 372                                bfd_get_filename (ofile->obfd));
 373               ALL_OBJFILE_OSECTIONS (ofile, osect)
 374                 {
 375                   print_objfile_section_info (ofile->obfd, osect, arg);
 376                 }
 377             }
 378         }
 379       else
 380         bfd_map_over_sections (exec_bfd, print_bfd_section_info, arg);
 381     }
 382
 383   if (core_bfd)
 384     {
 385       printf_filtered (_("Core file:\n"));
 386       printf_filtered ("    `%s', ", bfd_get_filename (core_bfd));
 387       wrap_here ("        ");
 388       printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
 389       bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
 390     }
 391 }
 392
 393 static void
 394 maintenance_print_statistics (char *args, int from_tty)
 395 {
 396   print_objfile_statistics ();
 397   print_symbol_bcache_statistics ();
 398 }
 399
 400 static void
 401 maintenance_print_architecture (char *args, int from_tty)
 402 {
 403   struct gdbarch *gdbarch = get_current_arch ();
 404
 405   if (args == NULL)
 406     gdbarch_dump (gdbarch, gdb_stdout);
 407   else
 408     {
 409       struct cleanup *cleanups;
 410       struct ui_file *file = gdb_fopen (args, "w");
 411
 412       if (file == NULL)
 413         perror_with_name (_("maintenance print architecture"));
 414       cleanups = make_cleanup_ui_file_delete (file);
 415       gdbarch_dump (gdbarch, file);
 416       do_cleanups (cleanups);
 417     }
 418 }
 419
 420 /* The "maintenance print" command is defined as a prefix, with
 421    allow_unknown 0.  Therefore, its own definition is called only for
 422    "maintenance print" with no args.  */
 423
 424 static void
 425 maintenance_print_command (char *arg, int from_tty)
 426 {
 427   printf_unfiltered (_("\"maintenance print\" must be followed "
 428                        "by the name of a print command.\n"));
 429   help_list (maintenanceprintlist, "maintenance print ", all_commands,
 430              gdb_stdout);
 431 }
 432
 433 /* The "maintenance translate-address" command converts a section and address
 434    to a symbol.  This can be called in two ways:
 435    maintenance translate-address <secname> <addr>
 436    or   maintenance translate-address <addr>.  */
 437
 438 static void
 439 maintenance_translate_address (char *arg, int from_tty)
 440 {
 441   CORE_ADDR address;
 442   struct obj_section *sect;
 443   char *p;
 444   struct bound_minimal_symbol sym;
 445   struct objfile *objfile;
 446
 447   if (arg == NULL || *arg == 0)
 448     error (_("requires argument (address or section + address)"));
 449
 450   sect = NULL;
 451   p = arg;
 452
 453   if (!isdigit (*p))
 454     {                           /* See if we have a valid section name.  */
 455       while (*p && !isspace (*p))       /* Find end of section name.  */
 456         p++;
 457       if (*p == '\000')         /* End of command?  */
 458         error (_("Need to specify <section-name> and <address>"));
 459       *p++ = '\000';
 460       p = skip_spaces (p);
 461
 462       ALL_OBJSECTIONS (objfile, sect)
 463       {
 464         if (strcmp (sect->the_bfd_section->name, arg) == 0)
 465           break;
 466       }
 467
 468       if (!objfile)
 469         error (_("Unknown section %s."), arg);
 470     }
 471
 472   address = parse_and_eval_address (p);
 473
 474   if (sect)
 475     sym = lookup_minimal_symbol_by_pc_section (address, sect);
 476   else
 477     sym = lookup_minimal_symbol_by_pc (address);
 478
 479   if (sym.minsym)
 480     {
 481       const char *symbol_name = MSYMBOL_PRINT_NAME (sym.minsym);
 482       const char *symbol_offset
 483         = pulongest (address - BMSYMBOL_VALUE_ADDRESS (sym));
 484
 485       sect = MSYMBOL_OBJ_SECTION(sym.objfile, sym.minsym);
 486       if (sect != NULL)
 487         {
 488           const char *section_name;
 489           const char *obj_name;
 490
 491           gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
 492           section_name = sect->the_bfd_section->name;
 493
 494           gdb_assert (sect->objfile && objfile_name (sect->objfile));
 495           obj_name = objfile_name (sect->objfile);
 496
 497           if (MULTI_OBJFILE_P ())
 498             printf_filtered (_("%s + %s in section %s of %s\n"),
 499                              symbol_name, symbol_offset,
 500                              section_name, obj_name);
 501           else
 502             printf_filtered (_("%s + %s in section %s\n"),
 503                              symbol_name, symbol_offset, section_name);
 504         }
 505       else
 506         printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
 507     }
 508   else if (sect)
 509     printf_filtered (_("no symbol at %s:%s\n"),
 510                      sect->the_bfd_section->name, hex_string (address));
 511   else
 512     printf_filtered (_("no symbol at %s\n"), hex_string (address));
 513
 514   return;
 515 }
 516
 517
 518 /* When a command is deprecated the user will be warned the first time
 519    the command is used.  If possible, a replacement will be
 520    offered.  */
 521
 522 static void
 523 maintenance_deprecate (char *args, int from_tty)
 524 {
 525   if (args == NULL || *args == '\0')
 526     {
 527       printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
 528 the command you want to deprecate, and optionally the replacement command\n\
 529 enclosed in quotes.\n"));
 530     }
 531
 532   maintenance_do_deprecate (args, 1);
 533
 534 }
 535
 536
 537 static void
 538 maintenance_undeprecate (char *args, int from_tty)
 539 {
 540   if (args == NULL || *args == '\0')
 541     {
 542       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 543 the command you want to undeprecate.\n"));
 544     }
 545
 546   maintenance_do_deprecate (args, 0);
 547
 548 }
 549
 550 /* You really shouldn't be using this.  It is just for the testsuite.
 551    Rather, you should use deprecate_cmd() when the command is created
 552    in _initialize_blah().
 553
 554    This function deprecates a command and optionally assigns it a
 555    replacement.  */
 556
 557 static void
 558 maintenance_do_deprecate (char *text, int deprecate)
 559 {
 560   struct cmd_list_element *alias = NULL;
 561   struct cmd_list_element *prefix_cmd = NULL;
 562   struct cmd_list_element *cmd = NULL;
 563
 564   char *start_ptr = NULL;
 565   char *end_ptr = NULL;
 566   int len;
 567   char *replacement = NULL;
 568
 569   if (text == NULL)
 570     return;
 571
 572   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 573     {
 574       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 575       return;
 576     }
 577
 578   if (deprecate)
 579     {
 580       /* Look for a replacement command.  */
 581       start_ptr = strchr (text, '\"');
 582       if (start_ptr != NULL)
 583         {
 584           start_ptr++;
 585           end_ptr = strrchr (start_ptr, '\"');
 586           if (end_ptr != NULL)
 587             {
 588               len = end_ptr - start_ptr;
 589               start_ptr[len] = '\0';
 590               replacement = xstrdup (start_ptr);
 591             }
 592         }
 593     }
 594
 595   if (!start_ptr || !end_ptr)
 596     replacement = NULL;
 597
 598
 599   /* If they used an alias, we only want to deprecate the alias.
 600
 601      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 602      string was allocated at compile time we don't want to free the
 603      memory.  */
 604   if (alias)
 605     {
 606       if (alias->malloced_replacement)
 607         xfree ((char *) alias->replacement);
 608
 609       if (deprecate)
 610         {
 611           alias->deprecated_warn_user = 1;
 612           alias->cmd_deprecated = 1;
 613         }
 614       else
 615         {
 616           alias->deprecated_warn_user = 0;
 617           alias->cmd_deprecated = 0;
 618         }
 619       alias->replacement = replacement;
 620       alias->malloced_replacement = 1;
 621       return;
 622     }
 623   else if (cmd)
 624     {
 625       if (cmd->malloced_replacement)
 626         xfree ((char *) cmd->replacement);
 627
 628       if (deprecate)
 629         {
 630           cmd->deprecated_warn_user = 1;
 631           cmd->cmd_deprecated = 1;
 632         }
 633       else
 634         {
 635           cmd->deprecated_warn_user = 0;
 636           cmd->cmd_deprecated = 0;
 637         }
 638       cmd->replacement = replacement;
 639       cmd->malloced_replacement = 1;
 640       return;
 641     }
 642   xfree (replacement);
 643 }
 644
 645 /* Maintenance set/show framework.  */
 646
 647 struct cmd_list_element *maintenance_set_cmdlist;
 648 struct cmd_list_element *maintenance_show_cmdlist;
 649
 650 static void
 651 maintenance_set_cmd (char *args, int from_tty)
 652 {
 653   printf_unfiltered (_("\"maintenance set\" must be followed "
 654                        "by the name of a set command.\n"));
 655   help_list (maintenance_set_cmdlist, "maintenance set ", all_commands,
 656              gdb_stdout);
 657 }
 658
 659 static void
 660 maintenance_show_cmd (char *args, int from_tty)
 661 {
 662   cmd_show_list (maintenance_show_cmdlist, from_tty, "");
 663 }
 664
 665 /* Profiling support.  */
 666
 667 static int maintenance_profile_p;
 668 static void
 669 show_maintenance_profile_p (struct ui_file *file, int from_tty,
 670                             struct cmd_list_element *c, const char *value)
 671 {
 672   fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
 673 }
 674
 675 #ifdef HAVE__ETEXT
 676 extern char _etext;
 677 #define TEXTEND &_etext
 678 #elif defined (HAVE_ETEXT)
 679 extern char etext;
 680 #define TEXTEND &etext
 681 #endif
 682
 683 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
 684
 685 static int profiling_state;
 686
 687 EXTERN_C void _mcleanup (void);
 688
 689 static void
 690 mcleanup_wrapper (void)
 691 {
 692   if (profiling_state)
 693     _mcleanup ();
 694 }
 695
 696 EXTERN_C void monstartup (unsigned long, unsigned long);
 697 extern int main ();
 698
 699 static void
 700 maintenance_set_profile_cmd (char *args, int from_tty,
 701                              struct cmd_list_element *c)
 702 {
 703   if (maintenance_profile_p == profiling_state)
 704     return;
 705
 706   profiling_state = maintenance_profile_p;
 707
 708   if (maintenance_profile_p)
 709     {
 710       static int profiling_initialized;
 711
 712       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,
 732                              struct cmd_list_element *c)
 733 {
 734   error (_("Profiling support is not available on this system."));
 735 }
 736 #endif
 737 \f
 738 /* If nonzero, display time usage both at startup and for each command.  */
 739
 740 static int per_command_time;
 741
 742 /* If nonzero, display space usage both at startup and for each command.  */
 743
 744 static int per_command_space;
 745
 746 /* If nonzero, display basic symtab stats for each command.  */
 747
 748 static int per_command_symtab;
 749
 750 /* mt per-command commands.  */
 751
 752 static struct cmd_list_element *per_command_setlist;
 753 static struct cmd_list_element *per_command_showlist;
 754
 755 /* Records a run time and space usage to be used as a base for
 756    reporting elapsed time or change in space.  */
 757
 758 struct cmd_stats
 759 {
 760   /* Zero if the saved time is from the beginning of GDB execution.
 761      One if from the beginning of an individual command execution.  */
 762   int msg_type;
 763   /* Track whether the stat was enabled at the start of the command
 764      so that we can avoid printing anything if it gets turned on by
 765      the current command.  */
 766   int time_enabled : 1;
 767   int space_enabled : 1;
 768   int symtab_enabled : 1;
 769   long start_cpu_time;
 770   struct timeval start_wall_time;
 771   long start_space;
 772   /* Total number of symtabs (over all objfiles).  */
 773   int start_nr_symtabs;
 774   /* A count of the compunits.  */
 775   int start_nr_compunit_symtabs;
 776   /* Total number of blocks.  */
 777   int start_nr_blocks;
 778 };
 779
 780 /* Set whether to display time statistics to NEW_VALUE
 781    (non-zero means true).  */
 782
 783 void
 784 set_per_command_time (int new_value)
 785 {
 786   per_command_time = new_value;
 787 }
 788
 789 /* Set whether to display space statistics to NEW_VALUE
 790    (non-zero means true).  */
 791
 792 void
 793 set_per_command_space (int new_value)
 794 {
 795   per_command_space = new_value;
 796 }
 797
 798 /* Count the number of symtabs and blocks.  */
 799
 800 static void
 801 count_symtabs_and_blocks (int *nr_symtabs_ptr, int *nr_compunit_symtabs_ptr,
 802                           int *nr_blocks_ptr)
 803 {
 804   struct objfile *o;
 805   struct compunit_symtab *cu;
 806   struct symtab *s;
 807   int nr_symtabs = 0;
 808   int nr_compunit_symtabs = 0;
 809   int nr_blocks = 0;
 810
 811   /* When collecting statistics during startup, this is called before
 812      pretty much anything in gdb has been initialized, and thus
 813      current_program_space may be NULL.  */
 814   if (current_program_space != NULL)
 815     {
 816       ALL_COMPUNITS (o, cu)
 817         {
 818           ++nr_compunit_symtabs;
 819           nr_blocks += BLOCKVECTOR_NBLOCKS (COMPUNIT_BLOCKVECTOR (cu));
 820           ALL_COMPUNIT_FILETABS (cu, s)
 821             ++nr_symtabs;
 822         }
 823     }
 824
 825   *nr_symtabs_ptr = nr_symtabs;
 826   *nr_compunit_symtabs_ptr = nr_compunit_symtabs;
 827   *nr_blocks_ptr = nr_blocks;
 828 }
 829
 830 /* As indicated by display_time and display_space, report GDB's elapsed time
 831    and space usage from the base time and space provided in ARG, which
 832    must be a pointer to a struct cmd_stat.  This function is intended
 833    to be called as a cleanup.  */
 834
 835 static void
 836 report_command_stats (void *arg)
 837 {
 838   struct cmd_stats *start_stats = (struct cmd_stats *) arg;
 839   int msg_type = start_stats->msg_type;
 840
 841   if (start_stats->time_enabled && per_command_time)
 842     {
 843       long cmd_time = get_run_time () - start_stats->start_cpu_time;
 844       struct timeval now_wall_time, delta_wall_time, wait_time;
 845
 846       gettimeofday (&now_wall_time, NULL);
 847       timeval_sub (&delta_wall_time,
 848                    &now_wall_time, &start_stats->start_wall_time);
 849
 850       /* Subtract time spend in prompt_for_continue from walltime.  */
 851       wait_time = get_prompt_for_continue_wait_time ();
 852       timeval_sub (&delta_wall_time, &delta_wall_time, &wait_time);
 853
 854       printf_unfiltered (msg_type == 0
 855                          ? _("Startup time: %ld.%06ld (cpu), %ld.%06ld (wall)\n")
 856                          : _("Command execution time: %ld.%06ld (cpu), %ld.%06ld (wall)\n"),
 857                          cmd_time / 1000000, cmd_time % 1000000,
 858                          (long) delta_wall_time.tv_sec,
 859                          (long) delta_wall_time.tv_usec);
 860     }
 861
 862   if (start_stats->space_enabled && per_command_space)
 863     {
 864 #ifdef HAVE_SBRK
 865       char *lim = (char *) sbrk (0);
 866
 867       long space_now = lim - lim_at_start;
 868       long space_diff = space_now - start_stats->start_space;
 869
 870       printf_unfiltered (msg_type == 0
 871                          ? _("Space used: %ld (%s%ld during startup)\n")
 872                          : _("Space used: %ld (%s%ld for this command)\n"),
 873                          space_now,
 874                          (space_diff >= 0 ? "+" : ""),
 875                          space_diff);
 876 #endif
 877     }
 878
 879   if (start_stats->symtab_enabled && per_command_symtab)
 880     {
 881       int nr_symtabs, nr_compunit_symtabs, nr_blocks;
 882
 883       count_symtabs_and_blocks (&nr_symtabs, &nr_compunit_symtabs, &nr_blocks);
 884       printf_unfiltered (_("#symtabs: %d (+%d),"
 885                            " #compunits: %d (+%d),"
 886                            " #blocks: %d (+%d)\n"),
 887                          nr_symtabs,
 888                          nr_symtabs - start_stats->start_nr_symtabs,
 889                          nr_compunit_symtabs,
 890                          (nr_compunit_symtabs
 891                           - start_stats->start_nr_compunit_symtabs),
 892                          nr_blocks,
 893                          nr_blocks - start_stats->start_nr_blocks);
 894     }
 895 }
 896
 897 /* Create a cleanup that reports time and space used since its creation.
 898    MSG_TYPE is zero for gdb startup, otherwise it is one(1) to report
 899    data for individual commands.  */
 900
 901 struct cleanup *
 902 make_command_stats_cleanup (int msg_type)
 903 {
 904   struct cmd_stats *new_stat;
 905
 906   /* Early exit if we're not reporting any stats.  It can be expensive to
 907      compute the pre-command values so don't collect them at all if we're
 908      not reporting stats.  Alas this doesn't work in the startup case because
 909      we don't know yet whether we will be reporting the stats.  For the
 910      startup case collect the data anyway (it should be cheap at this point),
 911      and leave it to the reporter to decide whether to print them.  */
 912   if (msg_type != 0
 913       && !per_command_time
 914       && !per_command_space
 915       && !per_command_symtab)
 916     return make_cleanup (null_cleanup, 0);
 917
 918   new_stat = XCNEW (struct cmd_stats);
 919
 920   new_stat->msg_type = msg_type;
 921
 922   if (msg_type == 0 || per_command_space)
 923     {
 924 #ifdef HAVE_SBRK
 925       char *lim = (char *) sbrk (0);
 926       new_stat->start_space = lim - lim_at_start;
 927       new_stat->space_enabled = 1;
 928 #endif
 929     }
 930
 931   if (msg_type == 0 || per_command_time)
 932     {
 933       new_stat->start_cpu_time = get_run_time ();
 934       gettimeofday (&new_stat->start_wall_time, NULL);
 935       new_stat->time_enabled = 1;
 936     }
 937
 938   if (msg_type == 0 || per_command_symtab)
 939     {
 940       int nr_symtabs, nr_compunit_symtabs, nr_blocks;
 941
 942       count_symtabs_and_blocks (&nr_symtabs, &nr_compunit_symtabs, &nr_blocks);
 943       new_stat->start_nr_symtabs = nr_symtabs;
 944       new_stat->start_nr_compunit_symtabs = nr_compunit_symtabs;
 945       new_stat->start_nr_blocks = nr_blocks;
 946       new_stat->symtab_enabled = 1;
 947     }
 948
 949   /* Initalize timer to keep track of how long we waited for the user.  */
 950   reset_prompt_for_continue_wait_time ();
 951
 952   return make_cleanup_dtor (report_command_stats, new_stat, xfree);
 953 }
 954
 955 /* Handle unknown "mt set per-command" arguments.
 956    In this case have "mt set per-command on|off" affect every setting.  */
 957
 958 static void
 959 set_per_command_cmd (char *args, int from_tty)
 960 {
 961   struct cmd_list_element *list;
 962   int val;
 963
 964   val = parse_cli_boolean_value (args);
 965   if (val < 0)
 966     error (_("Bad value for 'mt set per-command no'."));
 967
 968   for (list = per_command_setlist; list != NULL; list = list->next)
 969     if (list->var_type == var_boolean)
 970       {
 971         gdb_assert (list->type == set_cmd);
 972         do_set_command (args, from_tty, list);
 973       }
 974 }
 975
 976 /* Command "show per-command" displays summary of all the current
 977    "show per-command " settings.  */
 978
 979 static void
 980 show_per_command_cmd (char *args, int from_tty)
 981 {
 982   cmd_show_list (per_command_showlist, from_tty, "");
 983 }
 984 \f
 985
 986 /* The "maintenance selftest" command.  */
 987
 988 static void
 989 maintenance_selftest (char *args, int from_tty)
 990 {
 991   run_self_tests ();
 992 }
 993
 994 \f
 995 void
 996 _initialize_maint_cmds (void)
 997 {
 998   struct cmd_list_element *cmd;
 999
1000   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
1001 Commands for use by GDB maintainers.\n\
1002 Includes commands to dump specific internal GDB structures in\n\
1003 a human readable form, to cause GDB to deliberately dump core, etc."),
1004                   &maintenancelist, "maintenance ", 0,
1005                   &cmdlist);
1006
1007   add_com_alias ("mt", "maintenance", class_maintenance, 1);
1008
1009   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
1010 Commands for showing internal info about the program being debugged."),
1011                   &maintenanceinfolist, "maintenance info ", 0,
1012                   &maintenancelist);
1013   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
1014
1015   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
1016 List the BFD sections of the exec and core files. \n\
1017 Arguments may be any combination of:\n\
1018         [one or more section names]\n\
1019         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
1020         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
1021 Sections matching any argument will be listed (no argument\n\
1022 implies all sections).  In addition, the special argument\n\
1023         ALLOBJ\n\
1024 lists all sections from all object files, including shared libraries."),
1025            &maintenanceinfolist);
1026
1027   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
1028                   _("Maintenance command for printing GDB internal state."),
1029                   &maintenanceprintlist, "maintenance print ", 0,
1030                   &maintenancelist);
1031
1032   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
1033 Set GDB internal variables used by the GDB maintainer.\n\
1034 Configure variables internal to GDB that aid in GDB's maintenance"),
1035                   &maintenance_set_cmdlist, "maintenance set ",
1036                   0/*allow-unknown*/,
1037                   &maintenancelist);
1038
1039   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
1040 Show GDB internal variables used by the GDB maintainer.\n\
1041 Configure variables internal to GDB that aid in GDB's maintenance"),
1042                   &maintenance_show_cmdlist, "maintenance show ",
1043                   0/*allow-unknown*/,
1044                   &maintenancelist);
1045
1046 #ifndef _WIN32
1047   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
1048 Get fatal error; make debugger dump its core.\n\
1049 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
1050 itself a SIGQUIT signal."),
1051            &maintenancelist);
1052 #endif
1053
1054   add_cmd ("internal-error", class_maintenance,
1055            maintenance_internal_error, _("\
1056 Give GDB an internal error.\n\
1057 Cause GDB to behave as if an internal error was detected."),
1058            &maintenancelist);
1059
1060   add_cmd ("internal-warning", class_maintenance,
1061            maintenance_internal_warning, _("\
1062 Give GDB an internal warning.\n\
1063 Cause GDB to behave as if an internal warning was reported."),
1064            &maintenancelist);
1065
1066   add_cmd ("demangler-warning", class_maintenance,
1067            maintenance_demangler_warning, _("\
1068 Give GDB a demangler warning.\n\
1069 Cause GDB to behave as if a demangler warning was reported."),
1070            &maintenancelist);
1071
1072   cmd = add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
1073 This command has been moved to \"demangle\"."),
1074                  &maintenancelist);
1075   deprecate_cmd (cmd, "demangle");
1076
1077   add_prefix_cmd ("per-command", class_maintenance, set_per_command_cmd, _("\
1078 Per-command statistics settings."),
1079                     &per_command_setlist, "set per-command ",
1080                     1/*allow-unknown*/, &maintenance_set_cmdlist);
1081
1082   add_prefix_cmd ("per-command", class_maintenance, show_per_command_cmd, _("\
1083 Show per-command statistics settings."),
1084                     &per_command_showlist, "show per-command ",
1085                     0/*allow-unknown*/, &maintenance_show_cmdlist);
1086
1087   add_setshow_boolean_cmd ("time", class_maintenance,
1088                            &per_command_time, _("\
1089 Set whether to display per-command execution time."), _("\
1090 Show whether to display per-command execution time."),
1091                            _("\
1092 If enabled, the execution time for each command will be\n\
1093 displayed following the command's output."),
1094                            NULL, NULL,
1095                            &per_command_setlist, &per_command_showlist);
1096
1097   add_setshow_boolean_cmd ("space", class_maintenance,
1098                            &per_command_space, _("\
1099 Set whether to display per-command space usage."), _("\
1100 Show whether to display per-command space usage."),
1101                            _("\
1102 If enabled, the space usage for each command will be\n\
1103 displayed following the command's output."),
1104                            NULL, NULL,
1105                            &per_command_setlist, &per_command_showlist);
1106
1107   add_setshow_boolean_cmd ("symtab", class_maintenance,
1108                            &per_command_symtab, _("\
1109 Set whether to display per-command symtab statistics."), _("\
1110 Show whether to display per-command symtab statistics."),
1111                            _("\
1112 If enabled, the basic symtab statistics for each command will be\n\
1113 displayed following the command's output."),
1114                            NULL, NULL,
1115                            &per_command_setlist, &per_command_showlist);
1116
1117   /* This is equivalent to "mt set per-command time on".
1118      Kept because some people are used to typing "mt time 1".  */
1119   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
1120 Set the display of time usage.\n\
1121 If nonzero, will cause the execution time for each command to be\n\
1122 displayed, following the command's output."),
1123            &maintenancelist);
1124
1125   /* This is equivalent to "mt set per-command space on".
1126      Kept because some people are used to typing "mt space 1".  */
1127   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
1128 Set the display of space usage.\n\
1129 If nonzero, will cause the execution space for each command to be\n\
1130 displayed, following the command's output."),
1131            &maintenancelist);
1132
1133   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
1134 Print a type chain for a given symbol.\n\
1135 For each node in a type chain, print the raw data for each member of\n\
1136 the type structure, and the interpretation of the data."),
1137            &maintenanceprintlist);
1138
1139   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
1140            _("Print statistics about internal gdb state."),
1141            &maintenanceprintlist);
1142
1143   add_cmd ("architecture", class_maintenance,
1144            maintenance_print_architecture, _("\
1145 Print the internal architecture configuration.\n\
1146 Takes an optional file parameter."),
1147            &maintenanceprintlist);
1148
1149   add_cmd ("translate-address", class_maintenance,
1150            maintenance_translate_address,
1151            _("Translate a section name and address to a symbol."),
1152            &maintenancelist);
1153
1154   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
1155 Deprecate a command.  Note that this is just in here so the \n\
1156 testsuite can check the command deprecator. You probably shouldn't use this,\n\
1157 rather you should use the C function deprecate_cmd().  If you decide you \n\
1158 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
1159 replacement is optional."), &maintenancelist);
1160
1161   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
1162 Undeprecate a command.  Note that this is just in here so the \n\
1163 testsuite can check the command deprecator. You probably shouldn't use this,\n\
1164 If you decide you want to use it: maintenance undeprecate 'commandname'"),
1165            &maintenancelist);
1166
1167   add_cmd ("selftest", class_maintenance, maintenance_selftest, _("\
1168 Run gdb's unit tests.\n\
1169 Usage: maintenance selftest\n\
1170 This will run any unit tests that were built in to gdb.\n\
1171 gdb will abort if any test fails."),
1172            &maintenancelist);
1173
1174   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
1175 Set watchdog timer."), _("\
1176 Show watchdog timer."), _("\
1177 When non-zero, this timeout is used instead of waiting forever for a target\n\
1178 to finish a low-level step or continue operation.  If the specified amount\n\
1179 of time passes without a response from the target, an error occurs."),
1180                             NULL,
1181                             show_watchdog,
1182                             &setlist, &showlist);
1183
1184   add_setshow_boolean_cmd ("profile", class_maintenance,
1185                            &maintenance_profile_p, _("\
1186 Set internal profiling."), _("\
1187 Show internal profiling."), _("\
1188 When enabled GDB is profiled."),
1189                            maintenance_set_profile_cmd,
1190                            show_maintenance_profile_p,
1191                            &maintenance_set_cmdlist,
1192                            &maintenance_show_cmdlist);
1193 }