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