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