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