gdb/maint.c

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