gdb/maint.c

   1 /* Support for GDB maintenance commands.
   2
   3    Copyright (C) 1992-2019 Free Software Foundation, Inc.
   4
   5    Written by Fred Fish at Cygnus Support.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "defs.h"
  24 #include "arch-utils.h"
  25 #include <ctype.h>
  26 #include <signal.h>
  27 #include "command.h"
  28 #include "gdbcmd.h"
  29 #include "symtab.h"
  30 #include "block.h"
  31 #include "gdbtypes.h"
  32 #include "demangle.h"
  33 #include "gdbcore.h"
  34 #include "expression.h"         /* For language.h */
  35 #include "language.h"
  36 #include "symfile.h"
  37 #include "objfiles.h"
  38 #include "value.h"
  39 #include "top.h"
  40 #include "maint.h"
  41 #include "gdbsupport/selftest.h"
  42
  43 #include "cli/cli-decode.h"
  44 #include "cli/cli-utils.h"
  45 #include "cli/cli-setshow.h"
  46 #include "cli/cli-cmds.h"
  47
  48 static void maintenance_do_deprecate (const char *, int);
  49
  50 /* Access the maintenance subcommands.  */
  51
  52 static void
  53 maintenance_command (const char *args, int from_tty)
  54 {
  55   printf_unfiltered (_("\"maintenance\" must be followed by "
  56                        "the name of a maintenance command.\n"));
  57   help_list (maintenancelist, "maintenance ", all_commands, gdb_stdout);
  58 }
  59
  60 #ifndef _WIN32
  61 static void
  62 maintenance_dump_me (const char *args, int from_tty)
  63 {
  64   if (query (_("Should GDB dump core? ")))
  65     {
  66 #ifdef __DJGPP__
  67       /* SIGQUIT by default is ignored, so use SIGABRT instead.  */
  68       signal (SIGABRT, SIG_DFL);
  69       kill (getpid (), SIGABRT);
  70 #else
  71       signal (SIGQUIT, SIG_DFL);
  72       kill (getpid (), SIGQUIT);
  73 #endif
  74     }
  75 }
  76 #endif
  77
  78 /* Stimulate the internal error mechanism that GDB uses when an
  79    internal problem is detected.  Allows testing of the mechanism.
  80    Also useful when the user wants to drop a core file but not exit
  81    GDB.  */
  82
  83 static void
  84 maintenance_internal_error (const char *args, int from_tty)
  85 {
  86   internal_error (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
  87 }
  88
  89 /* Stimulate the internal error mechanism that GDB uses when an
  90    internal problem is detected.  Allows testing of the mechanism.
  91    Also useful when the user wants to drop a core file but not exit
  92    GDB.  */
  93
  94 static void
  95 maintenance_internal_warning (const char *args, int from_tty)
  96 {
  97   internal_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
  98 }
  99
 100 /* Stimulate the internal error mechanism that GDB uses when an
 101    demangler problem is detected.  Allows testing of the mechanism.  */
 102
 103 static void
 104 maintenance_demangler_warning (const char *args, int from_tty)
 105 {
 106   demangler_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
 107 }
 108
 109 /* Old command to demangle a string.  The command has been moved to "demangle".
 110    It is kept for now because otherwise "mt demangle" gets interpreted as
 111    "mt demangler-warning" which artificially creates an internal gdb error.  */
 112
 113 static void
 114 maintenance_demangle (const char *args, int from_tty)
 115 {
 116   printf_filtered (_("This command has been moved to \"demangle\".\n"));
 117 }
 118
 119 static void
 120 maintenance_time_display (const char *args, int from_tty)
 121 {
 122   if (args == NULL || *args == '\0')
 123     printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
 124   else
 125     set_per_command_time (strtol (args, NULL, 10));
 126 }
 127
 128 static void
 129 maintenance_space_display (const char *args, int from_tty)
 130 {
 131   if (args == NULL || *args == '\0')
 132     printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
 133   else
 134     set_per_command_space (strtol (args, NULL, 10));
 135 }
 136
 137 /* The "maintenance info" command is defined as a prefix, with
 138    allow_unknown 0.  Therefore, its own definition is called only for
 139    "maintenance info" with no args.  */
 140
 141 static void
 142 maintenance_info_command (const char *arg, int from_tty)
 143 {
 144   printf_unfiltered (_("\"maintenance info\" must be followed "
 145                        "by the name of an info command.\n"));
 146   help_list (maintenanceinfolist, "maintenance info ", all_commands,
 147              gdb_stdout);
 148 }
 149
 150 /* The "maintenance check" command is defined as a prefix, with
 151    allow_unknown 0.  Therefore, its own definition is called only for
 152    "maintenance check" with no args.  */
 153
 154 static void
 155 maintenance_check_command (const char *arg, int from_tty)
 156 {
 157   printf_unfiltered (_("\"maintenance check\" must be followed "
 158                        "by the name of a check command.\n"));
 159   help_list (maintenancechecklist, "maintenance check ", all_commands,
 160              gdb_stdout);
 161 }
 162
 163 /* Mini tokenizing lexer for 'maint info sections' command.  */
 164
 165 static int
 166 match_substring (const char *string, const char *substr)
 167 {
 168   int substr_len = strlen(substr);
 169   const char *tok;
 170
 171   while ((tok = strstr (string, substr)) != NULL)
 172     {
 173       /* Got a partial match.  Is it a whole word?  */
 174       if (tok == string
 175           || tok[-1] == ' '
 176           || tok[-1] == '\t')
 177       {
 178         /* Token is delimited at the front...  */
 179         if (tok[substr_len] == ' '
 180             || tok[substr_len] == '\t'
 181             || tok[substr_len] == '\0')
 182         {
 183           /* Token is delimited at the rear.  Got a whole-word match.  */
 184           return 1;
 185         }
 186       }
 187       /* Token didn't match as a whole word.  Advance and try again.  */
 188       string = tok + 1;
 189     }
 190   return 0;
 191 }
 192
 193 static int
 194 match_bfd_flags (const char *string, flagword flags)
 195 {
 196   if (flags & SEC_ALLOC)
 197     if (match_substring (string, "ALLOC"))
 198       return 1;
 199   if (flags & SEC_LOAD)
 200     if (match_substring (string, "LOAD"))
 201       return 1;
 202   if (flags & SEC_RELOC)
 203     if (match_substring (string, "RELOC"))
 204       return 1;
 205   if (flags & SEC_READONLY)
 206     if (match_substring (string, "READONLY"))
 207       return 1;
 208   if (flags & SEC_CODE)
 209     if (match_substring (string, "CODE"))
 210       return 1;
 211   if (flags & SEC_DATA)
 212     if (match_substring (string, "DATA"))
 213       return 1;
 214   if (flags & SEC_ROM)
 215     if (match_substring (string, "ROM"))
 216       return 1;
 217   if (flags & SEC_CONSTRUCTOR)
 218     if (match_substring (string, "CONSTRUCTOR"))
 219       return 1;
 220   if (flags & SEC_HAS_CONTENTS)
 221     if (match_substring (string, "HAS_CONTENTS"))
 222       return 1;
 223   if (flags & SEC_NEVER_LOAD)
 224     if (match_substring (string, "NEVER_LOAD"))
 225       return 1;
 226   if (flags & SEC_COFF_SHARED_LIBRARY)
 227     if (match_substring (string, "COFF_SHARED_LIBRARY"))
 228       return 1;
 229   if (flags & SEC_IS_COMMON)
 230     if (match_substring (string, "IS_COMMON"))
 231       return 1;
 232
 233   return 0;
 234 }
 235
 236 static void
 237 print_bfd_flags (flagword flags)
 238 {
 239   if (flags & SEC_ALLOC)
 240     printf_filtered (" ALLOC");
 241   if (flags & SEC_LOAD)
 242     printf_filtered (" LOAD");
 243   if (flags & SEC_RELOC)
 244     printf_filtered (" RELOC");
 245   if (flags & SEC_READONLY)
 246     printf_filtered (" READONLY");
 247   if (flags & SEC_CODE)
 248     printf_filtered (" CODE");
 249   if (flags & SEC_DATA)
 250     printf_filtered (" DATA");
 251   if (flags & SEC_ROM)
 252     printf_filtered (" ROM");
 253   if (flags & SEC_CONSTRUCTOR)
 254     printf_filtered (" CONSTRUCTOR");
 255   if (flags & SEC_HAS_CONTENTS)
 256     printf_filtered (" HAS_CONTENTS");
 257   if (flags & SEC_NEVER_LOAD)
 258     printf_filtered (" NEVER_LOAD");
 259   if (flags & SEC_COFF_SHARED_LIBRARY)
 260     printf_filtered (" COFF_SHARED_LIBRARY");
 261   if (flags & SEC_IS_COMMON)
 262     printf_filtered (" IS_COMMON");
 263 }
 264
 265 static void
 266 maint_print_section_info (const char *name, flagword flags,
 267                           CORE_ADDR addr, CORE_ADDR endaddr,
 268                           unsigned long filepos, int addr_size)
 269 {
 270   printf_filtered ("    %s", hex_string_custom (addr, addr_size));
 271   printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
 272   printf_filtered (" at %s",
 273                    hex_string_custom ((unsigned long) filepos, 8));
 274   printf_filtered (": %s", name);
 275   print_bfd_flags (flags);
 276   printf_filtered ("\n");
 277 }
 278
 279 static void
 280 print_bfd_section_info (bfd *abfd,
 281                         asection *asect,
 282                         void *datum)
 283 {
 284   flagword flags = bfd_get_section_flags (abfd, asect);
 285   const char *name = bfd_section_name (abfd, asect);
 286   const char *arg = (const char *) datum;
 287
 288   if (arg == NULL || *arg == '\0'
 289       || match_substring (arg, name)
 290       || match_bfd_flags (arg, flags))
 291     {
 292       struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 293       int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 294       CORE_ADDR addr, endaddr;
 295
 296       addr = bfd_section_vma (abfd, asect);
 297       endaddr = addr + bfd_section_size (abfd, asect);
 298       printf_filtered (" [%d] ", gdb_bfd_section_index (abfd, asect));
 299       maint_print_section_info (name, flags, addr, endaddr,
 300                                 asect->filepos, addr_size);
 301     }
 302 }
 303
 304 static void
 305 print_objfile_section_info (bfd *abfd,
 306                             struct obj_section *asect,
 307                             const char *string)
 308 {
 309   flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
 310   const char *name = bfd_section_name (abfd, asect->the_bfd_section);
 311
 312   if (string == NULL || *string == '\0'
 313       || match_substring (string, name)
 314       || match_bfd_flags (string, flags))
 315     {
 316       struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 317       int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 318
 319       maint_print_section_info (name, flags,
 320                                 obj_section_addr (asect),
 321                                 obj_section_endaddr (asect),
 322                                 asect->the_bfd_section->filepos,
 323                                 addr_size);
 324     }
 325 }
 326
 327 static void
 328 maintenance_info_sections (const char *arg, int from_tty)
 329 {
 330   if (exec_bfd)
 331     {
 332       struct obj_section *osect;
 333       bool allobj = false;
 334
 335       printf_filtered (_("Exec file:\n"));
 336       printf_filtered ("    `%s', ", bfd_get_filename (exec_bfd));
 337       wrap_here ("        ");
 338       printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
 339
 340       /* Only this function cares about the 'ALLOBJ' argument;
 341          if 'ALLOBJ' is the only argument, discard it rather than
 342          passing it down to print_objfile_section_info (which
 343          wouldn't know how to handle it).  */
 344       if (arg && strcmp (arg, "ALLOBJ") == 0)
 345         {
 346           arg = NULL;
 347           allobj = true;
 348         }
 349
 350       for (objfile *ofile : current_program_space->objfiles ())
 351         {
 352           if (allobj)
 353             printf_filtered (_("  Object file: %s\n"),
 354                              bfd_get_filename (ofile->obfd));
 355           ALL_OBJFILE_OSECTIONS (ofile, osect)
 356             {
 357               if (!allobj && ofile->obfd != exec_bfd)
 358                 continue;
 359               print_objfile_section_info (ofile->obfd, osect, arg);
 360             }
 361         }
 362     }
 363
 364   if (core_bfd)
 365     {
 366       printf_filtered (_("Core file:\n"));
 367       printf_filtered ("    `%s', ", bfd_get_filename (core_bfd));
 368       wrap_here ("        ");
 369       printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
 370       bfd_map_over_sections (core_bfd, print_bfd_section_info, (void *) arg);
 371     }
 372 }
 373
 374 static void
 375 maintenance_print_statistics (const char *args, int from_tty)
 376 {
 377   print_objfile_statistics ();
 378   print_symbol_bcache_statistics ();
 379 }
 380
 381 static void
 382 maintenance_print_architecture (const char *args, int from_tty)
 383 {
 384   struct gdbarch *gdbarch = get_current_arch ();
 385
 386   if (args == NULL)
 387     gdbarch_dump (gdbarch, gdb_stdout);
 388   else
 389     {
 390       stdio_file file;
 391
 392       if (!file.open (args, "w"))
 393         perror_with_name (_("maintenance print architecture"));
 394       gdbarch_dump (gdbarch, &file);
 395     }
 396 }
 397
 398 /* The "maintenance print" command is defined as a prefix, with
 399    allow_unknown 0.  Therefore, its own definition is called only for
 400    "maintenance print" with no args.  */
 401
 402 static void
 403 maintenance_print_command (const char *arg, int from_tty)
 404 {
 405   printf_unfiltered (_("\"maintenance print\" must be followed "
 406                        "by the name of a print command.\n"));
 407   help_list (maintenanceprintlist, "maintenance print ", all_commands,
 408              gdb_stdout);
 409 }
 410
 411 /* The "maintenance translate-address" command converts a section and address
 412    to a symbol.  This can be called in two ways:
 413    maintenance translate-address <secname> <addr>
 414    or   maintenance translate-address <addr>.  */
 415
 416 static void
 417 maintenance_translate_address (const char *arg, int from_tty)
 418 {
 419   CORE_ADDR address;
 420   struct obj_section *sect;
 421   const char *p;
 422   struct bound_minimal_symbol sym;
 423
 424   if (arg == NULL || *arg == 0)
 425     error (_("requires argument (address or section + address)"));
 426
 427   sect = NULL;
 428   p = arg;
 429
 430   if (!isdigit (*p))
 431     {                           /* See if we have a valid section name.  */
 432       while (*p && !isspace (*p))       /* Find end of section name.  */
 433         p++;
 434       if (*p == '\000')         /* End of command?  */
 435         error (_("Need to specify section name and address"));
 436
 437       int arg_len = p - arg;
 438       p = skip_spaces (p + 1);
 439
 440       for (objfile *objfile : current_program_space->objfiles ())
 441         ALL_OBJFILE_OSECTIONS (objfile, sect)
 442           {
 443             if (strncmp (sect->the_bfd_section->name, arg, arg_len) == 0)
 444               goto found;
 445           }
 446
 447       error (_("Unknown section %s."), arg);
 448     found: ;
 449     }
 450
 451   address = parse_and_eval_address (p);
 452
 453   if (sect)
 454     sym = lookup_minimal_symbol_by_pc_section (address, sect);
 455   else
 456     sym = lookup_minimal_symbol_by_pc (address);
 457
 458   if (sym.minsym)
 459     {
 460       const char *symbol_name = MSYMBOL_PRINT_NAME (sym.minsym);
 461       const char *symbol_offset
 462         = pulongest (address - BMSYMBOL_VALUE_ADDRESS (sym));
 463
 464       sect = MSYMBOL_OBJ_SECTION(sym.objfile, sym.minsym);
 465       if (sect != NULL)
 466         {
 467           const char *section_name;
 468           const char *obj_name;
 469
 470           gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
 471           section_name = sect->the_bfd_section->name;
 472
 473           gdb_assert (sect->objfile && objfile_name (sect->objfile));
 474           obj_name = objfile_name (sect->objfile);
 475
 476           if (MULTI_OBJFILE_P ())
 477             printf_filtered (_("%s + %s in section %s of %s\n"),
 478                              symbol_name, symbol_offset,
 479                              section_name, obj_name);
 480           else
 481             printf_filtered (_("%s + %s in section %s\n"),
 482                              symbol_name, symbol_offset, section_name);
 483         }
 484       else
 485         printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
 486     }
 487   else if (sect)
 488     printf_filtered (_("no symbol at %s:%s\n"),
 489                      sect->the_bfd_section->name, hex_string (address));
 490   else
 491     printf_filtered (_("no symbol at %s\n"), hex_string (address));
 492
 493   return;
 494 }
 495
 496
 497 /* When a command is deprecated the user will be warned the first time
 498    the command is used.  If possible, a replacement will be
 499    offered.  */
 500
 501 static void
 502 maintenance_deprecate (const char *args, int from_tty)
 503 {
 504   if (args == NULL || *args == '\0')
 505     {
 506       printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
 507 the command you want to deprecate, and optionally the replacement command\n\
 508 enclosed in quotes.\n"));
 509     }
 510
 511   maintenance_do_deprecate (args, 1);
 512 }
 513
 514
 515 static void
 516 maintenance_undeprecate (const char *args, int from_tty)
 517 {
 518   if (args == NULL || *args == '\0')
 519     {
 520       printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
 521 the command you want to undeprecate.\n"));
 522     }
 523
 524   maintenance_do_deprecate (args, 0);
 525 }
 526
 527 /* You really shouldn't be using this.  It is just for the testsuite.
 528    Rather, you should use deprecate_cmd() when the command is created
 529    in _initialize_blah().
 530
 531    This function deprecates a command and optionally assigns it a
 532    replacement.  */
 533
 534 static void
 535 maintenance_do_deprecate (const char *text, int deprecate)
 536 {
 537   struct cmd_list_element *alias = NULL;
 538   struct cmd_list_element *prefix_cmd = NULL;
 539   struct cmd_list_element *cmd = NULL;
 540
 541   const char *start_ptr = NULL;
 542   const char *end_ptr = NULL;
 543   int len;
 544   char *replacement = NULL;
 545
 546   if (text == NULL)
 547     return;
 548
 549   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
 550     {
 551       printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
 552       return;
 553     }
 554
 555   if (deprecate)
 556     {
 557       /* Look for a replacement command.  */
 558       start_ptr = strchr (text, '\"');
 559       if (start_ptr != NULL)
 560         {
 561           start_ptr++;
 562           end_ptr = strrchr (start_ptr, '\"');
 563           if (end_ptr != NULL)
 564             {
 565               len = end_ptr - start_ptr;
 566               replacement = savestring (start_ptr, len);
 567             }
 568         }
 569     }
 570
 571   if (!start_ptr || !end_ptr)
 572     replacement = NULL;
 573
 574
 575   /* If they used an alias, we only want to deprecate the alias.
 576
 577      Note the MALLOCED_REPLACEMENT test.  If the command's replacement
 578      string was allocated at compile time we don't want to free the
 579      memory.  */
 580   if (alias)
 581     {
 582       if (alias->malloced_replacement)
 583         xfree ((char *) alias->replacement);
 584
 585       if (deprecate)
 586         {
 587           alias->deprecated_warn_user = 1;
 588           alias->cmd_deprecated = 1;
 589         }
 590       else
 591         {
 592           alias->deprecated_warn_user = 0;
 593           alias->cmd_deprecated = 0;
 594         }
 595       alias->replacement = replacement;
 596       alias->malloced_replacement = 1;
 597       return;
 598     }
 599   else if (cmd)
 600     {
 601       if (cmd->malloced_replacement)
 602         xfree ((char *) cmd->replacement);
 603
 604       if (deprecate)
 605         {
 606           cmd->deprecated_warn_user = 1;
 607           cmd->cmd_deprecated = 1;
 608         }
 609       else
 610         {
 611           cmd->deprecated_warn_user = 0;
 612           cmd->cmd_deprecated = 0;
 613         }
 614       cmd->replacement = replacement;
 615       cmd->malloced_replacement = 1;
 616       return;
 617     }
 618   xfree (replacement);
 619 }
 620
 621 /* Maintenance set/show framework.  */
 622
 623 struct cmd_list_element *maintenance_set_cmdlist;
 624 struct cmd_list_element *maintenance_show_cmdlist;
 625
 626 static void
 627 maintenance_set_cmd (const char *args, int from_tty)
 628 {
 629   printf_unfiltered (_("\"maintenance set\" must be followed "
 630                        "by the name of a set command.\n"));
 631   help_list (maintenance_set_cmdlist, "maintenance set ", all_commands,
 632              gdb_stdout);
 633 }
 634
 635 static void
 636 maintenance_show_cmd (const char *args, int from_tty)
 637 {
 638   cmd_show_list (maintenance_show_cmdlist, from_tty, "");
 639 }
 640
 641 /* "maintenance with" command.  */
 642
 643 static void
 644 maintenance_with_cmd (const char *args, int from_tty)
 645 {
 646   with_command_1 ("maintenance set ", maintenance_set_cmdlist, args, from_tty);
 647 }
 648
 649 /* "maintenance with" command completer.  */
 650
 651 static void
 652 maintenance_with_cmd_completer (struct cmd_list_element *ignore,
 653                                 completion_tracker &tracker,
 654                                 const char *text, const char * /*word*/)
 655 {
 656   with_command_completer_1 ("maintenance set ", tracker,  text);
 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 (const 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 (const 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   int nr_symtabs = 0;
 774   int nr_compunit_symtabs = 0;
 775   int nr_blocks = 0;
 776
 777   /* When collecting statistics during startup, this is called before
 778      pretty much anything in gdb has been initialized, and thus
 779      current_program_space may be NULL.  */
 780   if (current_program_space != NULL)
 781     {
 782       for (objfile *o : current_program_space->objfiles ())
 783         {
 784           for (compunit_symtab *cu : o->compunits ())
 785             {
 786               ++nr_compunit_symtabs;
 787               nr_blocks += BLOCKVECTOR_NBLOCKS (COMPUNIT_BLOCKVECTOR (cu));
 788               nr_symtabs += std::distance (compunit_filetabs (cu).begin (),
 789                                            compunit_filetabs (cu).end ());
 790             }
 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       print_time (_("command finished"));
 820
 821       using namespace std::chrono;
 822
 823       run_time_clock::duration cmd_time
 824         = run_time_clock::now () - m_start_cpu_time;
 825
 826       steady_clock::duration wall_time
 827         = steady_clock::now () - m_start_wall_time;
 828       /* Subtract time spend in prompt_for_continue from walltime.  */
 829       wall_time -= get_prompt_for_continue_wait_time ();
 830
 831       printf_unfiltered (!m_msg_type
 832                          ? _("Startup time: %.6f (cpu), %.6f (wall)\n")
 833                          : _("Command execution time: %.6f (cpu), %.6f (wall)\n"),
 834                          duration<double> (cmd_time).count (),
 835                          duration<double> (wall_time).count ());
 836     }
 837
 838   if (m_space_enabled && per_command_space)
 839     {
 840 #ifdef HAVE_USEFUL_SBRK
 841       char *lim = (char *) sbrk (0);
 842
 843       long space_now = lim - lim_at_start;
 844       long space_diff = space_now - m_start_space;
 845
 846       printf_unfiltered (!m_msg_type
 847                          ? _("Space used: %ld (%s%ld during startup)\n")
 848                          : _("Space used: %ld (%s%ld for this command)\n"),
 849                          space_now,
 850                          (space_diff >= 0 ? "+" : ""),
 851                          space_diff);
 852 #endif
 853     }
 854
 855   if (m_symtab_enabled && per_command_symtab)
 856     {
 857       int nr_symtabs, nr_compunit_symtabs, nr_blocks;
 858
 859       count_symtabs_and_blocks (&nr_symtabs, &nr_compunit_symtabs, &nr_blocks);
 860       printf_unfiltered (_("#symtabs: %d (+%d),"
 861                            " #compunits: %d (+%d),"
 862                            " #blocks: %d (+%d)\n"),
 863                          nr_symtabs,
 864                          nr_symtabs - m_start_nr_symtabs,
 865                          nr_compunit_symtabs,
 866                          (nr_compunit_symtabs
 867                           - m_start_nr_compunit_symtabs),
 868                          nr_blocks,
 869                          nr_blocks - m_start_nr_blocks);
 870     }
 871 }
 872
 873 scoped_command_stats::scoped_command_stats (bool msg_type)
 874 : m_msg_type (msg_type)
 875 {
 876   if (!m_msg_type || per_command_space)
 877     {
 878 #ifdef HAVE_USEFUL_SBRK
 879       char *lim = (char *) sbrk (0);
 880       m_start_space = lim - lim_at_start;
 881       m_space_enabled = 1;
 882 #endif
 883     }
 884   else
 885     m_space_enabled = 0;
 886
 887   if (msg_type == 0 || per_command_time)
 888     {
 889       using namespace std::chrono;
 890
 891       m_start_cpu_time = run_time_clock::now ();
 892       m_start_wall_time = steady_clock::now ();
 893       m_time_enabled = 1;
 894
 895       if (per_command_time)
 896         print_time (_("command started"));
 897     }
 898   else
 899     m_time_enabled = 0;
 900
 901   if (msg_type == 0 || per_command_symtab)
 902     {
 903       int nr_symtabs, nr_compunit_symtabs, nr_blocks;
 904
 905       count_symtabs_and_blocks (&nr_symtabs, &nr_compunit_symtabs, &nr_blocks);
 906       m_start_nr_symtabs = nr_symtabs;
 907       m_start_nr_compunit_symtabs = nr_compunit_symtabs;
 908       m_start_nr_blocks = nr_blocks;
 909       m_symtab_enabled = 1;
 910     }
 911   else
 912     m_symtab_enabled = 0;
 913
 914   /* Initialize timer to keep track of how long we waited for the user.  */
 915   reset_prompt_for_continue_wait_time ();
 916 }
 917
 918 /* See maint.h.  */
 919
 920 void
 921 scoped_command_stats::print_time (const char *msg)
 922 {
 923   using namespace std::chrono;
 924
 925   auto now = system_clock::now ();
 926   auto ticks = now.time_since_epoch ().count () / (1000 * 1000);
 927   auto millis = ticks % 1000;
 928
 929   std::time_t as_time = system_clock::to_time_t (now);
 930   struct tm *tm = localtime (&as_time);
 931
 932   char out[100];
 933   strftime (out, sizeof (out), "%F %H:%M:%S", tm);
 934
 935   printf_unfiltered ("%s.%03d - %s\n", out, (int) millis, msg);
 936 }
 937
 938 /* Handle unknown "mt set per-command" arguments.
 939    In this case have "mt set per-command on|off" affect every setting.  */
 940
 941 static void
 942 set_per_command_cmd (const char *args, int from_tty)
 943 {
 944   struct cmd_list_element *list;
 945   int val;
 946
 947   val = parse_cli_boolean_value (args);
 948   if (val < 0)
 949     error (_("Bad value for 'mt set per-command no'."));
 950
 951   for (list = per_command_setlist; list != NULL; list = list->next)
 952     if (list->var_type == var_boolean)
 953       {
 954         gdb_assert (list->type == set_cmd);
 955         do_set_command (args, from_tty, list);
 956       }
 957 }
 958
 959 /* Command "show per-command" displays summary of all the current
 960    "show per-command " settings.  */
 961
 962 static void
 963 show_per_command_cmd (const char *args, int from_tty)
 964 {
 965   cmd_show_list (per_command_showlist, from_tty, "");
 966 }
 967 \f
 968
 969 /* The "maintenance selftest" command.  */
 970
 971 static void
 972 maintenance_selftest (const char *args, int from_tty)
 973 {
 974 #if GDB_SELF_TEST
 975   selftests::run_tests (args);
 976 #else
 977   printf_filtered (_("\
 978 Selftests have been disabled for this build.\n"));
 979 #endif
 980 }
 981
 982 static void
 983 maintenance_info_selftests (const char *arg, int from_tty)
 984 {
 985 #if GDB_SELF_TEST
 986   printf_filtered ("Registered selftests:\n");
 987   selftests::for_each_selftest ([] (const std::string &name) {
 988     printf_filtered (" - %s\n", name.c_str ());
 989   });
 990 #else
 991   printf_filtered (_("\
 992 Selftests have been disabled for this build.\n"));
 993 #endif
 994 }
 995
 996 \f
 997 void
 998 _initialize_maint_cmds (void)
 999 {
1000   struct cmd_list_element *cmd;
1001
1002   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
1003 Commands for use by GDB maintainers.\n\
1004 Includes commands to dump specific internal GDB structures in\n\
1005 a human readable form, to cause GDB to deliberately dump core, etc."),
1006                   &maintenancelist, "maintenance ", 0,
1007                   &cmdlist);
1008
1009   add_com_alias ("mt", "maintenance", class_maintenance, 1);
1010
1011   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
1012 Commands for showing internal info about the program being debugged."),
1013                   &maintenanceinfolist, "maintenance info ", 0,
1014                   &maintenancelist);
1015   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
1016
1017   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
1018 List the BFD sections of the exec and core files.\n\
1019 Arguments may be any combination of:\n\
1020         [one or more section names]\n\
1021         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
1022         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
1023 Sections matching any argument will be listed (no argument\n\
1024 implies all sections).  In addition, the special argument\n\
1025         ALLOBJ\n\
1026 lists all sections from all object files, including shared libraries."),
1027            &maintenanceinfolist);
1028
1029   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
1030                   _("Maintenance command for printing GDB internal state."),
1031                   &maintenanceprintlist, "maintenance print ", 0,
1032                   &maintenancelist);
1033
1034   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
1035 Set GDB internal variables used by the GDB maintainer.\n\
1036 Configure variables internal to GDB that aid in GDB's maintenance"),
1037                   &maintenance_set_cmdlist, "maintenance set ",
1038                   0/*allow-unknown*/,
1039                   &maintenancelist);
1040
1041   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
1042 Show GDB internal variables used by the GDB maintainer.\n\
1043 Configure variables internal to GDB that aid in GDB's maintenance"),
1044                   &maintenance_show_cmdlist, "maintenance show ",
1045                   0/*allow-unknown*/,
1046                   &maintenancelist);
1047
1048   cmd = add_cmd ("with", class_maintenance, maintenance_with_cmd, _("\
1049 Like \"with\", but works with \"maintenance set\" variables.\n\
1050 Usage: maintenance with SETTING [VALUE] [-- COMMAND]\n\
1051 With no COMMAND, repeats the last executed command.\n\
1052 SETTING is any setting you can change with the \"maintenance set\"\n\
1053 subcommands."),
1054                  &maintenancelist);
1055   set_cmd_completer_handle_brkchars (cmd, maintenance_with_cmd_completer);
1056
1057 #ifndef _WIN32
1058   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
1059 Get fatal error; make debugger dump its core.\n\
1060 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
1061 itself a SIGQUIT signal."),
1062            &maintenancelist);
1063 #endif
1064
1065   add_cmd ("internal-error", class_maintenance,
1066            maintenance_internal_error, _("\
1067 Give GDB an internal error.\n\
1068 Cause GDB to behave as if an internal error was detected."),
1069            &maintenancelist);
1070
1071   add_cmd ("internal-warning", class_maintenance,
1072            maintenance_internal_warning, _("\
1073 Give GDB an internal warning.\n\
1074 Cause GDB to behave as if an internal warning was reported."),
1075            &maintenancelist);
1076
1077   add_cmd ("demangler-warning", class_maintenance,
1078            maintenance_demangler_warning, _("\
1079 Give GDB a demangler warning.\n\
1080 Cause GDB to behave as if a demangler warning was reported."),
1081            &maintenancelist);
1082
1083   cmd = add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
1084 This command has been moved to \"demangle\"."),
1085                  &maintenancelist);
1086   deprecate_cmd (cmd, "demangle");
1087
1088   add_prefix_cmd ("per-command", class_maintenance, set_per_command_cmd, _("\
1089 Per-command statistics settings."),
1090                     &per_command_setlist, "maintenance set per-command ",
1091                     1/*allow-unknown*/, &maintenance_set_cmdlist);
1092
1093   add_prefix_cmd ("per-command", class_maintenance, show_per_command_cmd, _("\
1094 Show per-command statistics settings."),
1095                     &per_command_showlist, "maintenance show per-command ",
1096                     0/*allow-unknown*/, &maintenance_show_cmdlist);
1097
1098   add_setshow_boolean_cmd ("time", class_maintenance,
1099                            &per_command_time, _("\
1100 Set whether to display per-command execution time."), _("\
1101 Show whether to display per-command execution time."),
1102                            _("\
1103 If enabled, the execution time for each command will be\n\
1104 displayed following the command's output."),
1105                            NULL, NULL,
1106                            &per_command_setlist, &per_command_showlist);
1107
1108   add_setshow_boolean_cmd ("space", class_maintenance,
1109                            &per_command_space, _("\
1110 Set whether to display per-command space usage."), _("\
1111 Show whether to display per-command space usage."),
1112                            _("\
1113 If enabled, the space usage for each command will be\n\
1114 displayed following the command's output."),
1115                            NULL, NULL,
1116                            &per_command_setlist, &per_command_showlist);
1117
1118   add_setshow_boolean_cmd ("symtab", class_maintenance,
1119                            &per_command_symtab, _("\
1120 Set whether to display per-command symtab statistics."), _("\
1121 Show whether to display per-command symtab statistics."),
1122                            _("\
1123 If enabled, the basic symtab statistics for each command will be\n\
1124 displayed following the command's output."),
1125                            NULL, NULL,
1126                            &per_command_setlist, &per_command_showlist);
1127
1128   /* This is equivalent to "mt set per-command time on".
1129      Kept because some people are used to typing "mt time 1".  */
1130   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
1131 Set the display of time usage.\n\
1132 If nonzero, will cause the execution time for each command to be\n\
1133 displayed, following the command's output."),
1134            &maintenancelist);
1135
1136   /* This is equivalent to "mt set per-command space on".
1137      Kept because some people are used to typing "mt space 1".  */
1138   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
1139 Set the display of space usage.\n\
1140 If nonzero, will cause the execution space for each command to be\n\
1141 displayed, following the command's output."),
1142            &maintenancelist);
1143
1144   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
1145 Print a type chain for a given symbol.\n\
1146 For each node in a type chain, print the raw data for each member of\n\
1147 the type structure, and the interpretation of the data."),
1148            &maintenanceprintlist);
1149
1150   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
1151            _("Print statistics about internal gdb state."),
1152            &maintenanceprintlist);
1153
1154   add_cmd ("architecture", class_maintenance,
1155            maintenance_print_architecture, _("\
1156 Print the internal architecture configuration.\n\
1157 Takes an optional file parameter."),
1158            &maintenanceprintlist);
1159
1160   add_prefix_cmd ("check", class_maintenance, maintenance_check_command, _("\
1161 Commands for checking internal gdb state."),
1162                   &maintenancechecklist, "maintenance check ", 0,
1163                   &maintenancelist);
1164
1165   add_cmd ("translate-address", class_maintenance,
1166            maintenance_translate_address,
1167            _("Translate a section name and address to a symbol."),
1168            &maintenancelist);
1169
1170   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
1171 Deprecate a command (for testing purposes).\n\
1172 Usage: maintenance deprecate COMMANDNAME [\"REPLACEMENT\"]\n\
1173 This is used by the testsuite to check the command deprecator.\n\
1174 You probably shouldn't use this,\n\
1175 rather you should use the C function deprecate_cmd()."), &maintenancelist);
1176
1177   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
1178 Undeprecate a command (for testing purposes).\n\
1179 Usage: maintenance undeprecate COMMANDNAME\n\
1180 This is used by the testsuite to check the command deprecator.\n\
1181 You probably shouldn't use this."),
1182            &maintenancelist);
1183
1184   add_cmd ("selftest", class_maintenance, maintenance_selftest, _("\
1185 Run gdb's unit tests.\n\
1186 Usage: maintenance selftest [FILTER]\n\
1187 This will run any unit tests that were built in to gdb.\n\
1188 If a filter is given, only the tests with that value in their name will ran."),
1189            &maintenancelist);
1190
1191   add_cmd ("selftests", class_maintenance, maintenance_info_selftests,
1192          _("List the registered selftests."), &maintenanceinfolist);
1193
1194   add_setshow_boolean_cmd ("profile", class_maintenance,
1195                            &maintenance_profile_p, _("\
1196 Set internal profiling."), _("\
1197 Show internal profiling."), _("\
1198 When enabled GDB is profiled."),
1199                            maintenance_set_profile_cmd,
1200                            show_maintenance_profile_p,
1201                            &maintenance_set_cmdlist,
1202                            &maintenance_show_cmdlist);
1203 }