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