gdb/maint.c

   1 /* Support for GDB maintenance commands.
   2
   3    Copyright (C) 1992-2018 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_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 objfile *ofile;
 352           struct obj_section *osect;
 353
 354           /* Only this function cares about the 'ALLOBJ' argument;
 355              if 'ALLOBJ' is the only argument, discard it rather than
 356              passing it down to print_objfile_section_info (which
 357              wouldn't know how to handle it).  */
 358           if (strcmp (arg, "ALLOBJ") == 0)
 359             arg = NULL;
 360
 361           ALL_OBJFILES (ofile)
 362             {
 363               printf_filtered (_("  Object file: %s\n"),
 364                                bfd_get_filename (ofile->obfd));
 365               ALL_OBJFILE_OSECTIONS (ofile, osect)
 366                 {
 367                   print_objfile_section_info (ofile->obfd, osect, arg);
 368                 }
 369             }
 370         }
 371       else
 372         bfd_map_over_sections (exec_bfd, print_bfd_section_info, (void *) arg);
 373     }
 374
 375   if (core_bfd)
 376     {
 377       printf_filtered (_("Core file:\n"));
 378       printf_filtered ("    `%s', ", bfd_get_filename (core_bfd));
 379       wrap_here ("        ");
 380       printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
 381       bfd_map_over_sections (core_bfd, print_bfd_section_info, (void *) arg);
 382     }
 383 }
 384
 385 static void
 386 maintenance_print_statistics (const char *args, int from_tty)
 387 {
 388   print_objfile_statistics ();
 389   print_symbol_bcache_statistics ();
 390 }
 391
 392 static void
 393 maintenance_print_architecture (const char *args, int from_tty)
 394 {
 395   struct gdbarch *gdbarch = get_current_arch ();
 396
 397   if (args == NULL)
 398     gdbarch_dump (gdbarch, gdb_stdout);
 399   else
 400     {
 401       stdio_file file;
 402
 403       if (!file.open (args, "w"))
 404         perror_with_name (_("maintenance print architecture"));
 405       gdbarch_dump (gdbarch, &file);
 406     }
 407 }
 408
 409 /* The "maintenance print" command is defined as a prefix, with
 410    allow_unknown 0.  Therefore, its own definition is called only for
 411    "maintenance print" with no args.  */
 412
 413 static void
 414 maintenance_print_command (const char *arg, int from_tty)
 415 {
 416   printf_unfiltered (_("\"maintenance print\" must be followed "
 417                        "by the name of a print command.\n"));
 418   help_list (maintenanceprintlist, "maintenance print ", all_commands,
 419              gdb_stdout);
 420 }
 421
 422 /* The "maintenance translate-address" command converts a section and address
 423    to a symbol.  This can be called in two ways:
 424    maintenance translate-address <secname> <addr>
 425    or   maintenance translate-address <addr>.  */
 426
 427 static void
 428 maintenance_translate_address (const char *arg, int from_tty)
 429 {
 430   CORE_ADDR address;
 431   struct obj_section *sect;
 432   const char *p;
 433   struct bound_minimal_symbol sym;
 434   struct objfile *objfile;
 435
 436   if (arg == NULL || *arg == 0)
 437     error (_("requires argument (address or section + address)"));
 438
 439   sect = NULL;
 440   p = arg;
 441
 442   if (!isdigit (*p))
 443     {                           /* See if we have a valid section name.  */
 444       while (*p && !isspace (*p))       /* Find end of section name.  */
 445         p++;
 446       if (*p == '\000')         /* End of command?  */
 447         error (_("Need to specify section name and address"));
 448
 449       int arg_len = p - arg;
 450       p = skip_spaces (p + 1);
 451
 452       ALL_OBJSECTIONS (objfile, sect)
 453       {
 454         if (strncmp (sect->the_bfd_section->name, arg, arg_len) == 0)
 455           break;
 456       }
 457
 458       if (!objfile)
 459         error (_("Unknown section %s."), arg);
 460     }
 461
 462   address = parse_and_eval_address (p);
 463
 464   if (sect)
 465     sym = lookup_minimal_symbol_by_pc_section (address, sect);
 466   else
 467     sym = lookup_minimal_symbol_by_pc (address);
 468
 469   if (sym.minsym)
 470     {
 471       const char *symbol_name = MSYMBOL_PRINT_NAME (sym.minsym);
 472       const char *symbol_offset
 473         = pulongest (address - BMSYMBOL_VALUE_ADDRESS (sym));
 474
 475       sect = MSYMBOL_OBJ_SECTION(sym.objfile, sym.minsym);
 476       if (sect != NULL)
 477         {
 478           const char *section_name;
 479           const char *obj_name;
 480
 481           gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
 482           section_name = sect->the_bfd_section->name;
 483
 484           gdb_assert (sect->objfile && objfile_name (sect->objfile));
 485           obj_name = objfile_name (sect->objfile);
 486
 487           if (MULTI_OBJFILE_P ())
 488             printf_filtered (_("%s + %s in section %s of %s\n"),
 489                              symbol_name, symbol_offset,
 490                              section_name, obj_name);
 491           else
 492             printf_filtered (_("%s + %s in section %s\n"),
 493                              symbol_name, symbol_offset, section_name);
 494         }
 495       else
 496         printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
 497     }
 498   else if (sect)
 499     printf_filtered (_("no symbol at %s:%s\n"),
 500                      sect->the_bfd_section->name, hex_string (address));
 501   else
 502     printf_filtered (_("no symbol at %s\n"), hex_string (address));
 503
 504   return;
 505 }
 506
 507
 508 /* When a command is deprecated the user will be warned the first time
 509    the command is used.  If possible, a replacement will be
 510    offered.  */
 511
 512 static void
 513 maintenance_deprecate (const char *args, int from_tty)
 514 {
 515   if (args == NULL || *args == '\0')
 516     {
 517       printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
 518 the command you want to deprecate, and optionally the replacement command\n\
 519 enclosed in quotes.\n"));
 520     }
 521
 522   maintenance_do_deprecate (args, 1);
 523 }
 524
 525
 526 static void
 527 maintenance_undeprecate (const char *args, int from_tty)
 528 {
 529   if (args == NULL || *args == '\0')
 530     {
 531       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 532 the command you want to undeprecate.\n"));
 533     }
 534
 535   maintenance_do_deprecate (args, 0);
 536 }
 537
 538 /* You really shouldn't be using this.  It is just for the testsuite.
 539    Rather, you should use deprecate_cmd() when the command is created
 540    in _initialize_blah().
 541
 542    This function deprecates a command and optionally assigns it a
 543    replacement.  */
 544
 545 static void
 546 maintenance_do_deprecate (const char *text, int deprecate)
 547 {
 548   struct cmd_list_element *alias = NULL;
 549   struct cmd_list_element *prefix_cmd = NULL;
 550   struct cmd_list_element *cmd = NULL;
 551
 552   const char *start_ptr = NULL;
 553   const char *end_ptr = NULL;
 554   int len;
 555   char *replacement = NULL;
 556
 557   if (text == NULL)
 558     return;
 559
 560   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 561     {
 562       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 563       return;
 564     }
 565
 566   if (deprecate)
 567     {
 568       /* Look for a replacement command.  */
 569       start_ptr = strchr (text, '\"');
 570       if (start_ptr != NULL)
 571         {
 572           start_ptr++;
 573           end_ptr = strrchr (start_ptr, '\"');
 574           if (end_ptr != NULL)
 575             {
 576               len = end_ptr - start_ptr;
 577               replacement = savestring (start_ptr, len);
 578             }
 579         }
 580     }
 581
 582   if (!start_ptr || !end_ptr)
 583     replacement = NULL;
 584
 585
 586   /* If they used an alias, we only want to deprecate the alias.
 587
 588      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 589      string was allocated at compile time we don't want to free the
 590      memory.  */
 591   if (alias)
 592     {
 593       if (alias->malloced_replacement)
 594         xfree ((char *) alias->replacement);
 595
 596       if (deprecate)
 597         {
 598           alias->deprecated_warn_user = 1;
 599           alias->cmd_deprecated = 1;
 600         }
 601       else
 602         {
 603           alias->deprecated_warn_user = 0;
 604           alias->cmd_deprecated = 0;
 605         }
 606       alias->replacement = replacement;
 607       alias->malloced_replacement = 1;
 608       return;
 609     }
 610   else if (cmd)
 611     {
 612       if (cmd->malloced_replacement)
 613         xfree ((char *) cmd->replacement);
 614
 615       if (deprecate)
 616         {
 617           cmd->deprecated_warn_user = 1;
 618           cmd->cmd_deprecated = 1;
 619         }
 620       else
 621         {
 622           cmd->deprecated_warn_user = 0;
 623           cmd->cmd_deprecated = 0;
 624         }
 625       cmd->replacement = replacement;
 626       cmd->malloced_replacement = 1;
 627       return;
 628     }
 629   xfree (replacement);
 630 }
 631
 632 /* Maintenance set/show framework.  */
 633
 634 struct cmd_list_element *maintenance_set_cmdlist;
 635 struct cmd_list_element *maintenance_show_cmdlist;
 636
 637 static void
 638 maintenance_set_cmd (const char *args, int from_tty)
 639 {
 640   printf_unfiltered (_("\"maintenance set\" must be followed "
 641                        "by the name of a set command.\n"));
 642   help_list (maintenance_set_cmdlist, "maintenance set ", all_commands,
 643              gdb_stdout);
 644 }
 645
 646 static void
 647 maintenance_show_cmd (const char *args, int from_tty)
 648 {
 649   cmd_show_list (maintenance_show_cmdlist, from_tty, "");
 650 }
 651
 652 /* Profiling support.  */
 653
 654 static int maintenance_profile_p;
 655 static void
 656 show_maintenance_profile_p (struct ui_file *file, int from_tty,
 657                             struct cmd_list_element *c, const char *value)
 658 {
 659   fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
 660 }
 661
 662 #ifdef HAVE__ETEXT
 663 extern char _etext;
 664 #define TEXTEND &_etext
 665 #elif defined (HAVE_ETEXT)
 666 extern char etext;
 667 #define TEXTEND &etext
 668 #endif
 669
 670 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
 671
 672 static int profiling_state;
 673
 674 EXTERN_C void _mcleanup (void);
 675
 676 static void
 677 mcleanup_wrapper (void)
 678 {
 679   if (profiling_state)
 680     _mcleanup ();
 681 }
 682
 683 EXTERN_C void monstartup (unsigned long, unsigned long);
 684 extern int main ();
 685
 686 static void
 687 maintenance_set_profile_cmd (const char *args, int from_tty,
 688                              struct cmd_list_element *c)
 689 {
 690   if (maintenance_profile_p == profiling_state)
 691     return;
 692
 693   profiling_state = maintenance_profile_p;
 694
 695   if (maintenance_profile_p)
 696     {
 697       static int profiling_initialized;
 698
 699       if (!profiling_initialized)
 700         {
 701           atexit (mcleanup_wrapper);
 702           profiling_initialized = 1;
 703         }
 704
 705       /* "main" is now always the first function in the text segment, so use
 706          its address for monstartup.  */
 707       monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
 708     }
 709   else
 710     {
 711       extern void _mcleanup (void);
 712
 713       _mcleanup ();
 714     }
 715 }
 716 #else
 717 static void
 718 maintenance_set_profile_cmd (const char *args, int from_tty,
 719                              struct cmd_list_element *c)
 720 {
 721   error (_("Profiling support is not available on this system."));
 722 }
 723 #endif
 724 \f
 725 /* If nonzero, display time usage both at startup and for each command.  */
 726
 727 static int per_command_time;
 728
 729 /* If nonzero, display space usage both at startup and for each command.  */
 730
 731 static int per_command_space;
 732
 733 /* If nonzero, display basic symtab stats for each command.  */
 734
 735 static int per_command_symtab;
 736
 737 /* mt per-command commands.  */
 738
 739 static struct cmd_list_element *per_command_setlist;
 740 static struct cmd_list_element *per_command_showlist;
 741
 742 /* Set whether to display time statistics to NEW_VALUE
 743    (non-zero means true).  */
 744
 745 void
 746 set_per_command_time (int new_value)
 747 {
 748   per_command_time = new_value;
 749 }
 750
 751 /* Set whether to display space statistics to NEW_VALUE
 752    (non-zero means true).  */
 753
 754 void
 755 set_per_command_space (int new_value)
 756 {
 757   per_command_space = new_value;
 758 }
 759
 760 /* Count the number of symtabs and blocks.  */
 761
 762 static void
 763 count_symtabs_and_blocks (int *nr_symtabs_ptr, int *nr_compunit_symtabs_ptr,
 764                           int *nr_blocks_ptr)
 765 {
 766   struct objfile *o;
 767   struct compunit_symtab *cu;
 768   struct symtab *s;
 769   int nr_symtabs = 0;
 770   int nr_compunit_symtabs = 0;
 771   int nr_blocks = 0;
 772
 773   /* When collecting statistics during startup, this is called before
 774      pretty much anything in gdb has been initialized, and thus
 775      current_program_space may be NULL.  */
 776   if (current_program_space != NULL)
 777     {
 778       ALL_COMPUNITS (o, cu)
 779         {
 780           ++nr_compunit_symtabs;
 781           nr_blocks += BLOCKVECTOR_NBLOCKS (COMPUNIT_BLOCKVECTOR (cu));
 782           ALL_COMPUNIT_FILETABS (cu, s)
 783             ++nr_symtabs;
 784         }
 785     }
 786
 787   *nr_symtabs_ptr = nr_symtabs;
 788   *nr_compunit_symtabs_ptr = nr_compunit_symtabs;
 789   *nr_blocks_ptr = nr_blocks;
 790 }
 791
 792 /* As indicated by display_time and display_space, report GDB's
 793    elapsed time and space usage from the base time and space recorded
 794    in this object.  */
 795
 796 scoped_command_stats::~scoped_command_stats ()
 797 {
 798   /* Early exit if we're not reporting any stats.  It can be expensive to
 799      compute the pre-command values so don't collect them at all if we're
 800      not reporting stats.  Alas this doesn't work in the startup case because
 801      we don't know yet whether we will be reporting the stats.  For the
 802      startup case collect the data anyway (it should be cheap at this point),
 803      and leave it to the reporter to decide whether to print them.  */
 804   if (m_msg_type
 805       && !per_command_time
 806       && !per_command_space
 807       && !per_command_symtab)
 808     return;
 809
 810   if (m_time_enabled && per_command_time)
 811     {
 812       using namespace std::chrono;
 813
 814       run_time_clock::duration cmd_time
 815         = run_time_clock::now () - m_start_cpu_time;
 816
 817       steady_clock::duration wall_time
 818         = steady_clock::now () - m_start_wall_time;
 819       /* Subtract time spend in prompt_for_continue from walltime.  */
 820       wall_time -= get_prompt_for_continue_wait_time ();
 821
 822       printf_unfiltered (!m_msg_type
 823                          ? _("Startup time: %.6f (cpu), %.6f (wall)\n")
 824                          : _("Command execution time: %.6f (cpu), %.6f (wall)\n"),
 825                          duration<double> (cmd_time).count (),
 826                          duration<double> (wall_time).count ());
 827     }
 828
 829   if (m_space_enabled && per_command_space)
 830     {
 831 #ifdef HAVE_USEFUL_SBRK
 832       char *lim = (char *) sbrk (0);
 833
 834       long space_now = lim - lim_at_start;
 835       long space_diff = space_now - m_start_space;
 836
 837       printf_unfiltered (!m_msg_type
 838                          ? _("Space used: %ld (%s%ld during startup)\n")
 839                          : _("Space used: %ld (%s%ld for this command)\n"),
 840                          space_now,
 841                          (space_diff >= 0 ? "+" : ""),
 842                          space_diff);
 843 #endif
 844     }
 845
 846   if (m_symtab_enabled && per_command_symtab)
 847     {
 848       int nr_symtabs, nr_compunit_symtabs, nr_blocks;
 849
 850       count_symtabs_and_blocks (&nr_symtabs, &nr_compunit_symtabs, &nr_blocks);
 851       printf_unfiltered (_("#symtabs: %d (+%d),"
 852                            " #compunits: %d (+%d),"
 853                            " #blocks: %d (+%d)\n"),
 854                          nr_symtabs,
 855                          nr_symtabs - m_start_nr_symtabs,
 856                          nr_compunit_symtabs,
 857                          (nr_compunit_symtabs
 858                           - m_start_nr_compunit_symtabs),
 859                          nr_blocks,
 860                          nr_blocks - m_start_nr_blocks);
 861     }
 862 }
 863
 864 scoped_command_stats::scoped_command_stats (bool msg_type)
 865 : m_msg_type (msg_type)
 866 {
 867   if (!m_msg_type || per_command_space)
 868     {
 869 #ifdef HAVE_USEFUL_SBRK
 870       char *lim = (char *) sbrk (0);
 871       m_start_space = lim - lim_at_start;
 872       m_space_enabled = 1;
 873 #endif
 874     }
 875   else
 876     m_space_enabled = 0;
 877
 878   if (msg_type == 0 || per_command_time)
 879     {
 880       using namespace std::chrono;
 881
 882       m_start_cpu_time = run_time_clock::now ();
 883       m_start_wall_time = steady_clock::now ();
 884       m_time_enabled = 1;
 885     }
 886   else
 887     m_time_enabled = 0;
 888
 889   if (msg_type == 0 || per_command_symtab)
 890     {
 891       int nr_symtabs, nr_compunit_symtabs, nr_blocks;
 892
 893       count_symtabs_and_blocks (&nr_symtabs, &nr_compunit_symtabs, &nr_blocks);
 894       m_start_nr_symtabs = nr_symtabs;
 895       m_start_nr_compunit_symtabs = nr_compunit_symtabs;
 896       m_start_nr_blocks = nr_blocks;
 897       m_symtab_enabled = 1;
 898     }
 899   else
 900     m_symtab_enabled = 0;
 901
 902   /* Initialize timer to keep track of how long we waited for the user.  */
 903   reset_prompt_for_continue_wait_time ();
 904 }
 905
 906 /* Handle unknown "mt set per-command" arguments.
 907    In this case have "mt set per-command on|off" affect every setting.  */
 908
 909 static void
 910 set_per_command_cmd (const char *args, int from_tty)
 911 {
 912   struct cmd_list_element *list;
 913   int val;
 914
 915   val = parse_cli_boolean_value (args);
 916   if (val < 0)
 917     error (_("Bad value for 'mt set per-command no'."));
 918
 919   for (list = per_command_setlist; list != NULL; list = list->next)
 920     if (list->var_type == var_boolean)
 921       {
 922         gdb_assert (list->type == set_cmd);
 923         do_set_command (args, from_tty, list);
 924       }
 925 }
 926
 927 /* Command "show per-command" displays summary of all the current
 928    "show per-command " settings.  */
 929
 930 static void
 931 show_per_command_cmd (const char *args, int from_tty)
 932 {
 933   cmd_show_list (per_command_showlist, from_tty, "");
 934 }
 935 \f
 936
 937 /* The "maintenance selftest" command.  */
 938
 939 static void
 940 maintenance_selftest (const char *args, int from_tty)
 941 {
 942 #if GDB_SELF_TEST
 943   selftests::run_tests (args);
 944 #else
 945   printf_filtered (_("\
 946 Selftests have been disabled for this build.\n"));
 947 #endif
 948 }
 949
 950 static void
 951 maintenance_info_selftests (const char *arg, int from_tty)
 952 {
 953 #if GDB_SELF_TEST
 954   printf_filtered ("Registered selftests:\n");
 955   selftests::for_each_selftest ([] (const std::string &name) {
 956     printf_filtered (" - %s\n", name.c_str ());
 957   });
 958 #else
 959   printf_filtered (_("\
 960 Selftests have been disabled for this build.\n"));
 961 #endif
 962 }
 963
 964 \f
 965 void
 966 _initialize_maint_cmds (void)
 967 {
 968   struct cmd_list_element *cmd;
 969
 970   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
 971 Commands for use by GDB maintainers.\n\
 972 Includes commands to dump specific internal GDB structures in\n\
 973 a human readable form, to cause GDB to deliberately dump core, etc."),
 974                   &maintenancelist, "maintenance ", 0,
 975                   &cmdlist);
 976
 977   add_com_alias ("mt", "maintenance", class_maintenance, 1);
 978
 979   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
 980 Commands for showing internal info about the program being debugged."),
 981                   &maintenanceinfolist, "maintenance info ", 0,
 982                   &maintenancelist);
 983   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
 984
 985   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
 986 List the BFD sections of the exec and core files. \n\
 987 Arguments may be any combination of:\n\
 988         [one or more section names]\n\
 989         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
 990         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
 991 Sections matching any argument will be listed (no argument\n\
 992 implies all sections).  In addition, the special argument\n\
 993         ALLOBJ\n\
 994 lists all sections from all object files, including shared libraries."),
 995            &maintenanceinfolist);
 996
 997   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
 998                   _("Maintenance command for printing GDB internal state."),
 999                   &maintenanceprintlist, "maintenance print ", 0,
1000                   &maintenancelist);
1001
1002   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
1003 Set GDB internal variables used by the GDB maintainer.\n\
1004 Configure variables internal to GDB that aid in GDB's maintenance"),
1005                   &maintenance_set_cmdlist, "maintenance set ",
1006                   0/*allow-unknown*/,
1007                   &maintenancelist);
1008
1009   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
1010 Show GDB internal variables used by the GDB maintainer.\n\
1011 Configure variables internal to GDB that aid in GDB's maintenance"),
1012                   &maintenance_show_cmdlist, "maintenance show ",
1013                   0/*allow-unknown*/,
1014                   &maintenancelist);
1015
1016 #ifndef _WIN32
1017   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
1018 Get fatal error; make debugger dump its core.\n\
1019 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
1020 itself a SIGQUIT signal."),
1021            &maintenancelist);
1022 #endif
1023
1024   add_cmd ("internal-error", class_maintenance,
1025            maintenance_internal_error, _("\
1026 Give GDB an internal error.\n\
1027 Cause GDB to behave as if an internal error was detected."),
1028            &maintenancelist);
1029
1030   add_cmd ("internal-warning", class_maintenance,
1031            maintenance_internal_warning, _("\
1032 Give GDB an internal warning.\n\
1033 Cause GDB to behave as if an internal warning was reported."),
1034            &maintenancelist);
1035
1036   add_cmd ("demangler-warning", class_maintenance,
1037            maintenance_demangler_warning, _("\
1038 Give GDB a demangler warning.\n\
1039 Cause GDB to behave as if a demangler warning was reported."),
1040            &maintenancelist);
1041
1042   cmd = add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
1043 This command has been moved to \"demangle\"."),
1044                  &maintenancelist);
1045   deprecate_cmd (cmd, "demangle");
1046
1047   add_prefix_cmd ("per-command", class_maintenance, set_per_command_cmd, _("\
1048 Per-command statistics settings."),
1049                     &per_command_setlist, "maintenance set per-command ",
1050                     1/*allow-unknown*/, &maintenance_set_cmdlist);
1051
1052   add_prefix_cmd ("per-command", class_maintenance, show_per_command_cmd, _("\
1053 Show per-command statistics settings."),
1054                     &per_command_showlist, "maintenance show per-command ",
1055                     0/*allow-unknown*/, &maintenance_show_cmdlist);
1056
1057   add_setshow_boolean_cmd ("time", class_maintenance,
1058                            &per_command_time, _("\
1059 Set whether to display per-command execution time."), _("\
1060 Show whether to display per-command execution time."),
1061                            _("\
1062 If enabled, the execution time for each command will be\n\
1063 displayed following the command's output."),
1064                            NULL, NULL,
1065                            &per_command_setlist, &per_command_showlist);
1066
1067   add_setshow_boolean_cmd ("space", class_maintenance,
1068                            &per_command_space, _("\
1069 Set whether to display per-command space usage."), _("\
1070 Show whether to display per-command space usage."),
1071                            _("\
1072 If enabled, the space usage for each command will be\n\
1073 displayed following the command's output."),
1074                            NULL, NULL,
1075                            &per_command_setlist, &per_command_showlist);
1076
1077   add_setshow_boolean_cmd ("symtab", class_maintenance,
1078                            &per_command_symtab, _("\
1079 Set whether to display per-command symtab statistics."), _("\
1080 Show whether to display per-command symtab statistics."),
1081                            _("\
1082 If enabled, the basic symtab statistics for each command will be\n\
1083 displayed following the command's output."),
1084                            NULL, NULL,
1085                            &per_command_setlist, &per_command_showlist);
1086
1087   /* This is equivalent to "mt set per-command time on".
1088      Kept because some people are used to typing "mt time 1".  */
1089   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
1090 Set the display of time usage.\n\
1091 If nonzero, will cause the execution time for each command to be\n\
1092 displayed, following the command's output."),
1093            &maintenancelist);
1094
1095   /* This is equivalent to "mt set per-command space on".
1096      Kept because some people are used to typing "mt space 1".  */
1097   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
1098 Set the display of space usage.\n\
1099 If nonzero, will cause the execution space for each command to be\n\
1100 displayed, following the command's output."),
1101            &maintenancelist);
1102
1103   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
1104 Print a type chain for a given symbol.\n\
1105 For each node in a type chain, print the raw data for each member of\n\
1106 the type structure, and the interpretation of the data."),
1107            &maintenanceprintlist);
1108
1109   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
1110            _("Print statistics about internal gdb state."),
1111            &maintenanceprintlist);
1112
1113   add_cmd ("architecture", class_maintenance,
1114            maintenance_print_architecture, _("\
1115 Print the internal architecture configuration.\n\
1116 Takes an optional file parameter."),
1117            &maintenanceprintlist);
1118
1119   add_prefix_cmd ("check", class_maintenance, maintenance_check_command, _("\
1120 Commands for checking internal gdb state."),
1121                   &maintenancechecklist, "maintenance check ", 0,
1122                   &maintenancelist);
1123
1124   add_cmd ("translate-address", class_maintenance,
1125            maintenance_translate_address,
1126            _("Translate a section name and address to a symbol."),
1127            &maintenancelist);
1128
1129   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
1130 Deprecate 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 rather you should use the C function deprecate_cmd().  If you decide you \n\
1133 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
1134 replacement is optional."), &maintenancelist);
1135
1136   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
1137 Undeprecate a command.  Note that this is just in here so the \n\
1138 testsuite can check the command deprecator. You probably shouldn't use this,\n\
1139 If you decide you want to use it: maintenance undeprecate 'commandname'"),
1140            &maintenancelist);
1141
1142   add_cmd ("selftest", class_maintenance, maintenance_selftest, _("\
1143 Run gdb's unit tests.\n\
1144 Usage: maintenance selftest [filter]\n\
1145 This will run any unit tests that were built in to gdb.\n\
1146 If a filter is given, only the tests with that value in their name will ran."),
1147            &maintenancelist);
1148
1149   add_cmd ("selftests", class_maintenance, maintenance_info_selftests,
1150          _("List the registered selftests."), &maintenanceinfolist);
1151
1152   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
1153 Set watchdog timer."), _("\
1154 Show watchdog timer."), _("\
1155 When non-zero, this timeout is used instead of waiting forever for a target\n\
1156 to finish a low-level step or continue operation.  If the specified amount\n\
1157 of time passes without a response from the target, an error occurs."),
1158                             NULL,
1159                             show_watchdog,
1160                             &setlist, &showlist);
1161
1162   add_setshow_boolean_cmd ("profile", class_maintenance,
1163                            &maintenance_profile_p, _("\
1164 Set internal profiling."), _("\
1165 Show internal profiling."), _("\
1166 When enabled GDB is profiled."),
1167                            maintenance_set_profile_cmd,
1168                            show_maintenance_profile_p,
1169                            &maintenance_set_cmdlist,
1170                            &maintenance_show_cmdlist);
1171 }