gdb/maint.c

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