gdb/maint.c

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