gdb/maint.c

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