gdb/maint.c

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