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