Automatic date update in version.in
[platform/upstream/binutils.git] / 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 "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 /* Someday we should allow demangling for things other than just
143    explicit strings.  For example, we might want to be able to specify
144    the address of a string in either GDB's process space or the
145    debuggee's process space, and have gdb fetch and demangle that
146    string.  If we have a char* pointer "ptr" that points to a string,
147    we might want to be able to given just the name and have GDB
148    demangle and print what it points to, etc.  (FIXME)  */
149
150 static void
151 maintenance_demangle (char *args, int from_tty)
152 {
153   char *demangled;
154
155   if (args == NULL || *args == '\0')
156     {
157       printf_unfiltered (_("\"maintenance demangle\" takes "
158                            "an argument to demangle.\n"));
159     }
160   else
161     {
162       demangled = language_demangle (current_language, args, 
163                                      DMGL_ANSI | DMGL_PARAMS);
164       if (demangled != NULL)
165         {
166           printf_unfiltered ("%s\n", demangled);
167           xfree (demangled);
168         }
169       else
170         {
171           printf_unfiltered (_("Can't demangle \"%s\"\n"), args);
172         }
173     }
174 }
175
176 static void
177 maintenance_time_display (char *args, int from_tty)
178 {
179   if (args == NULL || *args == '\0')
180     printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
181   else
182     set_per_command_time (strtol (args, NULL, 10));
183 }
184
185 static void
186 maintenance_space_display (char *args, int from_tty)
187 {
188   if (args == NULL || *args == '\0')
189     printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
190   else
191     set_per_command_space (strtol (args, NULL, 10));
192 }
193
194 /* The "maintenance info" command is defined as a prefix, with
195    allow_unknown 0.  Therefore, its own definition is called only for
196    "maintenance info" with no args.  */
197
198 static void
199 maintenance_info_command (char *arg, int from_tty)
200 {
201   printf_unfiltered (_("\"maintenance info\" must be followed "
202                        "by the name of an info command.\n"));
203   help_list (maintenanceinfolist, "maintenance info ", all_commands,
204              gdb_stdout);
205 }
206
207 /* Mini tokenizing lexer for 'maint info sections' command.  */
208
209 static int
210 match_substring (const char *string, const char *substr)
211 {
212   int substr_len = strlen(substr);
213   const char *tok;
214
215   while ((tok = strstr (string, substr)) != NULL)
216     {
217       /* Got a partial match.  Is it a whole word?  */
218       if (tok == string
219           || tok[-1] == ' '
220           || tok[-1] == '\t')
221       {
222         /* Token is delimited at the front...  */
223         if (tok[substr_len] == ' '
224             || tok[substr_len] == '\t'
225             || tok[substr_len] == '\0')
226         {
227           /* Token is delimited at the rear.  Got a whole-word match.  */
228           return 1;
229         }
230       }
231       /* Token didn't match as a whole word.  Advance and try again.  */
232       string = tok + 1;
233     }
234   return 0;
235 }
236
237 static int 
238 match_bfd_flags (const char *string, flagword flags)
239 {
240   if (flags & SEC_ALLOC)
241     if (match_substring (string, "ALLOC"))
242       return 1;
243   if (flags & SEC_LOAD)
244     if (match_substring (string, "LOAD"))
245       return 1;
246   if (flags & SEC_RELOC)
247     if (match_substring (string, "RELOC"))
248       return 1;
249   if (flags & SEC_READONLY)
250     if (match_substring (string, "READONLY"))
251       return 1;
252   if (flags & SEC_CODE)
253     if (match_substring (string, "CODE"))
254       return 1;
255   if (flags & SEC_DATA)
256     if (match_substring (string, "DATA"))
257       return 1;
258   if (flags & SEC_ROM)
259     if (match_substring (string, "ROM"))
260       return 1;
261   if (flags & SEC_CONSTRUCTOR)
262     if (match_substring (string, "CONSTRUCTOR"))
263       return 1;
264   if (flags & SEC_HAS_CONTENTS)
265     if (match_substring (string, "HAS_CONTENTS"))
266       return 1;
267   if (flags & SEC_NEVER_LOAD)
268     if (match_substring (string, "NEVER_LOAD"))
269       return 1;
270   if (flags & SEC_COFF_SHARED_LIBRARY)
271     if (match_substring (string, "COFF_SHARED_LIBRARY"))
272       return 1;
273   if (flags & SEC_IS_COMMON)
274     if (match_substring (string, "IS_COMMON"))
275       return 1;
276
277   return 0;
278 }
279
280 static void
281 print_bfd_flags (flagword flags)
282 {
283   if (flags & SEC_ALLOC)
284     printf_filtered (" ALLOC");
285   if (flags & SEC_LOAD)
286     printf_filtered (" LOAD");
287   if (flags & SEC_RELOC)
288     printf_filtered (" RELOC");
289   if (flags & SEC_READONLY)
290     printf_filtered (" READONLY");
291   if (flags & SEC_CODE)
292     printf_filtered (" CODE");
293   if (flags & SEC_DATA)
294     printf_filtered (" DATA");
295   if (flags & SEC_ROM)
296     printf_filtered (" ROM");
297   if (flags & SEC_CONSTRUCTOR)
298     printf_filtered (" CONSTRUCTOR");
299   if (flags & SEC_HAS_CONTENTS)
300     printf_filtered (" HAS_CONTENTS");
301   if (flags & SEC_NEVER_LOAD)
302     printf_filtered (" NEVER_LOAD");
303   if (flags & SEC_COFF_SHARED_LIBRARY)
304     printf_filtered (" COFF_SHARED_LIBRARY");
305   if (flags & SEC_IS_COMMON)
306     printf_filtered (" IS_COMMON");
307 }
308
309 static void
310 maint_print_section_info (const char *name, flagword flags, 
311                           CORE_ADDR addr, CORE_ADDR endaddr, 
312                           unsigned long filepos, int addr_size)
313 {
314   printf_filtered ("    %s", hex_string_custom (addr, addr_size));
315   printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
316   printf_filtered (" at %s",
317                    hex_string_custom ((unsigned long) filepos, 8));
318   printf_filtered (": %s", name);
319   print_bfd_flags (flags);
320   printf_filtered ("\n");
321 }
322
323 static void
324 print_bfd_section_info (bfd *abfd, 
325                         asection *asect, 
326                         void *datum)
327 {
328   flagword flags = bfd_get_section_flags (abfd, asect);
329   const char *name = bfd_section_name (abfd, asect);
330   const char *arg = datum;
331
332   if (arg == NULL || *arg == '\0'
333       || match_substring (arg, name)
334       || match_bfd_flags (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                             const 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 ((char *) 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 ((char *) 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   /* When collecting statistics during startup, this is called before
834      pretty much anything in gdb has been initialized, and thus
835      current_program_space may be NULL.  */
836   if (current_program_space != NULL)
837     {
838       ALL_SYMTABS (o, s)
839         {
840           ++nr_symtabs;
841           if (s->primary)
842             {
843               ++nr_primary_symtabs;
844               nr_blocks += BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (s));
845             }
846         }
847     }
848
849   *nr_symtabs_ptr = nr_symtabs;
850   *nr_primary_symtabs_ptr = nr_primary_symtabs;
851   *nr_blocks_ptr = nr_blocks;
852 }
853
854 /* As indicated by display_time and display_space, report GDB's elapsed time
855    and space usage from the base time and space provided in ARG, which
856    must be a pointer to a struct cmd_stat.  This function is intended
857    to be called as a cleanup.  */
858
859 static void
860 report_command_stats (void *arg)
861 {
862   struct cmd_stats *start_stats = (struct cmd_stats *) arg;
863   int msg_type = start_stats->msg_type;
864
865   if (start_stats->time_enabled && per_command_time)
866     {
867       long cmd_time = get_run_time () - start_stats->start_cpu_time;
868       struct timeval now_wall_time, delta_wall_time, wait_time;
869
870       gettimeofday (&now_wall_time, NULL);
871       timeval_sub (&delta_wall_time,
872                    &now_wall_time, &start_stats->start_wall_time);
873
874       /* Subtract time spend in prompt_for_continue from walltime.  */
875       wait_time = get_prompt_for_continue_wait_time ();
876       timeval_sub (&delta_wall_time, &delta_wall_time, &wait_time);
877
878       printf_unfiltered (msg_type == 0
879                          ? _("Startup time: %ld.%06ld (cpu), %ld.%06ld (wall)\n")
880                          : _("Command execution time: %ld.%06ld (cpu), %ld.%06ld (wall)\n"),
881                          cmd_time / 1000000, cmd_time % 1000000,
882                          (long) delta_wall_time.tv_sec,
883                          (long) delta_wall_time.tv_usec);
884     }
885
886   if (start_stats->space_enabled && per_command_space)
887     {
888 #ifdef HAVE_SBRK
889       char *lim = (char *) sbrk (0);
890
891       long space_now = lim - lim_at_start;
892       long space_diff = space_now - start_stats->start_space;
893
894       printf_unfiltered (msg_type == 0
895                          ? _("Space used: %ld (%s%ld during startup)\n")
896                          : _("Space used: %ld (%s%ld for this command)\n"),
897                          space_now,
898                          (space_diff >= 0 ? "+" : ""),
899                          space_diff);
900 #endif
901     }
902
903   if (start_stats->symtab_enabled && per_command_symtab)
904     {
905       int nr_symtabs, nr_primary_symtabs, nr_blocks;
906
907       count_symtabs_and_blocks (&nr_symtabs, &nr_primary_symtabs, &nr_blocks);
908       printf_unfiltered (_("#symtabs: %d (+%d),"
909                            " #primary symtabs: %d (+%d),"
910                            " #blocks: %d (+%d)\n"),
911                          nr_symtabs,
912                          nr_symtabs - start_stats->start_nr_symtabs,
913                          nr_primary_symtabs,
914                          nr_primary_symtabs - start_stats->start_nr_primary_symtabs,
915                          nr_blocks,
916                          nr_blocks - start_stats->start_nr_blocks);
917     }
918 }
919
920 /* Create a cleanup that reports time and space used since its creation.
921    MSG_TYPE is zero for gdb startup, otherwise it is one(1) to report
922    data for individual commands.  */
923
924 struct cleanup *
925 make_command_stats_cleanup (int msg_type)
926 {
927   struct cmd_stats *new_stat;
928
929   /* Early exit if we're not reporting any stats.  It can be expensive to
930      compute the pre-command values so don't collect them at all if we're
931      not reporting stats.  Alas this doesn't work in the startup case because
932      we don't know yet whether we will be reporting the stats.  For the
933      startup case collect the data anyway (it should be cheap at this point),
934      and leave it to the reporter to decide whether to print them.  */
935   if (msg_type != 0
936       && !per_command_time
937       && !per_command_space
938       && !per_command_symtab)
939     return make_cleanup (null_cleanup, 0);
940
941   new_stat = XCNEW (struct cmd_stats);
942
943   new_stat->msg_type = msg_type;
944
945   if (msg_type == 0 || per_command_space)
946     {
947 #ifdef HAVE_SBRK
948       char *lim = (char *) sbrk (0);
949       new_stat->start_space = lim - lim_at_start;
950       new_stat->space_enabled = 1;
951 #endif
952     }
953
954   if (msg_type == 0 || per_command_time)
955     {
956       new_stat->start_cpu_time = get_run_time ();
957       gettimeofday (&new_stat->start_wall_time, NULL);
958       new_stat->time_enabled = 1;
959     }
960
961   if (msg_type == 0 || per_command_symtab)
962     {
963       int nr_symtabs, nr_primary_symtabs, nr_blocks;
964
965       count_symtabs_and_blocks (&nr_symtabs, &nr_primary_symtabs, &nr_blocks);
966       new_stat->start_nr_symtabs = nr_symtabs;
967       new_stat->start_nr_primary_symtabs = nr_primary_symtabs;
968       new_stat->start_nr_blocks = nr_blocks;
969       new_stat->symtab_enabled = 1;
970     }
971
972   /* Initalize timer to keep track of how long we waited for the user.  */
973   reset_prompt_for_continue_wait_time ();
974
975   return make_cleanup_dtor (report_command_stats, new_stat, xfree);
976 }
977
978 /* Handle unknown "mt set per-command" arguments.
979    In this case have "mt set per-command on|off" affect every setting.  */
980
981 static void
982 set_per_command_cmd (char *args, int from_tty)
983 {
984   struct cmd_list_element *list;
985   size_t length;
986   int val;
987
988   val = parse_cli_boolean_value (args);
989   if (val < 0)
990     error (_("Bad value for 'mt set per-command no'."));
991
992   for (list = per_command_setlist; list != NULL; list = list->next)
993     if (list->var_type == var_boolean)
994       {
995         gdb_assert (list->type == set_cmd);
996         do_set_command (args, from_tty, list);
997       }
998 }
999
1000 /* Command "show per-command" displays summary of all the current
1001    "show per-command " settings.  */
1002
1003 static void
1004 show_per_command_cmd (char *args, int from_tty)
1005 {
1006   cmd_show_list (per_command_showlist, from_tty, "");
1007 }
1008 \f
1009 void
1010 _initialize_maint_cmds (void)
1011 {
1012   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
1013 Commands for use by GDB maintainers.\n\
1014 Includes commands to dump specific internal GDB structures in\n\
1015 a human readable form, to cause GDB to deliberately dump core,\n\
1016 to test internal functions such as the C++/ObjC demangler, etc."),
1017                   &maintenancelist, "maintenance ", 0,
1018                   &cmdlist);
1019
1020   add_com_alias ("mt", "maintenance", class_maintenance, 1);
1021
1022   add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
1023 Commands for showing internal info about the program being debugged."),
1024                   &maintenanceinfolist, "maintenance info ", 0,
1025                   &maintenancelist);
1026   add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
1027
1028   add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
1029 List the BFD sections of the exec and core files. \n\
1030 Arguments may be any combination of:\n\
1031         [one or more section names]\n\
1032         ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
1033         HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
1034 Sections matching any argument will be listed (no argument\n\
1035 implies all sections).  In addition, the special argument\n\
1036         ALLOBJ\n\
1037 lists all sections from all object files, including shared libraries."),
1038            &maintenanceinfolist);
1039
1040   add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
1041                   _("Maintenance command for printing GDB internal state."),
1042                   &maintenanceprintlist, "maintenance print ", 0,
1043                   &maintenancelist);
1044
1045   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
1046 Set GDB internal variables used by the GDB maintainer.\n\
1047 Configure variables internal to GDB that aid in GDB's maintenance"),
1048                   &maintenance_set_cmdlist, "maintenance set ",
1049                   0/*allow-unknown*/,
1050                   &maintenancelist);
1051
1052   add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
1053 Show GDB internal variables used by the GDB maintainer.\n\
1054 Configure variables internal to GDB that aid in GDB's maintenance"),
1055                   &maintenance_show_cmdlist, "maintenance show ",
1056                   0/*allow-unknown*/,
1057                   &maintenancelist);
1058
1059 #ifndef _WIN32
1060   add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
1061 Get fatal error; make debugger dump its core.\n\
1062 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
1063 itself a SIGQUIT signal."),
1064            &maintenancelist);
1065 #endif
1066
1067   add_cmd ("internal-error", class_maintenance,
1068            maintenance_internal_error, _("\
1069 Give GDB an internal error.\n\
1070 Cause GDB to behave as if an internal error was detected."),
1071            &maintenancelist);
1072
1073   add_cmd ("internal-warning", class_maintenance,
1074            maintenance_internal_warning, _("\
1075 Give GDB an internal warning.\n\
1076 Cause GDB to behave as if an internal warning was reported."),
1077            &maintenancelist);
1078
1079   add_cmd ("demangler-warning", class_maintenance,
1080            maintenance_demangler_warning, _("\
1081 Give GDB a demangler warning.\n\
1082 Cause GDB to behave as if a demangler warning was reported."),
1083            &maintenancelist);
1084
1085   add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
1086 Demangle a C++/ObjC mangled name.\n\
1087 Call internal GDB demangler routine to demangle a C++ link name\n\
1088 and prints the result."),
1089            &maintenancelist);
1090
1091   add_prefix_cmd ("per-command", class_maintenance, set_per_command_cmd, _("\
1092 Per-command statistics settings."),
1093                     &per_command_setlist, "set per-command ",
1094                     1/*allow-unknown*/, &maintenance_set_cmdlist);
1095
1096   add_prefix_cmd ("per-command", class_maintenance, show_per_command_cmd, _("\
1097 Show per-command statistics settings."),
1098                     &per_command_showlist, "show per-command ",
1099                     0/*allow-unknown*/, &maintenance_show_cmdlist);
1100
1101   add_setshow_boolean_cmd ("time", class_maintenance,
1102                            &per_command_time, _("\
1103 Set whether to display per-command execution time."), _("\
1104 Show whether to display per-command execution time."),
1105                            _("\
1106 If enabled, the execution time for each command will be\n\
1107 displayed following the command's output."),
1108                            NULL, NULL,
1109                            &per_command_setlist, &per_command_showlist);
1110
1111   add_setshow_boolean_cmd ("space", class_maintenance,
1112                            &per_command_space, _("\
1113 Set whether to display per-command space usage."), _("\
1114 Show whether to display per-command space usage."),
1115                            _("\
1116 If enabled, the space usage for each command will be\n\
1117 displayed following the command's output."),
1118                            NULL, NULL,
1119                            &per_command_setlist, &per_command_showlist);
1120
1121   add_setshow_boolean_cmd ("symtab", class_maintenance,
1122                            &per_command_symtab, _("\
1123 Set whether to display per-command symtab statistics."), _("\
1124 Show whether to display per-command symtab statistics."),
1125                            _("\
1126 If enabled, the basic symtab statistics for each command will be\n\
1127 displayed following the command's output."),
1128                            NULL, NULL,
1129                            &per_command_setlist, &per_command_showlist);
1130
1131   /* This is equivalent to "mt set per-command time on".
1132      Kept because some people are used to typing "mt time 1".  */
1133   add_cmd ("time", class_maintenance, maintenance_time_display, _("\
1134 Set the display of time usage.\n\
1135 If nonzero, will cause the execution time for each command to be\n\
1136 displayed, following the command's output."),
1137            &maintenancelist);
1138
1139   /* This is equivalent to "mt set per-command space on".
1140      Kept because some people are used to typing "mt space 1".  */
1141   add_cmd ("space", class_maintenance, maintenance_space_display, _("\
1142 Set the display of space usage.\n\
1143 If nonzero, will cause the execution space for each command to be\n\
1144 displayed, following the command's output."),
1145            &maintenancelist);
1146
1147   add_cmd ("type", class_maintenance, maintenance_print_type, _("\
1148 Print a type chain for a given symbol.\n\
1149 For each node in a type chain, print the raw data for each member of\n\
1150 the type structure, and the interpretation of the data."),
1151            &maintenanceprintlist);
1152
1153   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
1154            _("Print statistics about internal gdb state."),
1155            &maintenanceprintlist);
1156
1157   add_cmd ("architecture", class_maintenance,
1158            maintenance_print_architecture, _("\
1159 Print the internal architecture configuration.\n\
1160 Takes an optional file parameter."),
1161            &maintenanceprintlist);
1162
1163   add_cmd ("translate-address", class_maintenance,
1164            maintenance_translate_address,
1165            _("Translate a section name and address to a symbol."),
1166            &maintenancelist);
1167
1168   add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
1169 Deprecate a command.  Note that this is just in here so the \n\
1170 testsuite can check the command deprecator. You probably shouldn't use this,\n\
1171 rather you should use the C function deprecate_cmd().  If you decide you \n\
1172 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
1173 replacement is optional."), &maintenancelist);
1174
1175   add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
1176 Undeprecate a command.  Note that this is just in here so the \n\
1177 testsuite can check the command deprecator. You probably shouldn't use this,\n\
1178 If you decide you want to use it: maintenance undeprecate 'commandname'"),
1179            &maintenancelist);
1180
1181   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
1182 Set watchdog timer."), _("\
1183 Show watchdog timer."), _("\
1184 When non-zero, this timeout is used instead of waiting forever for a target\n\
1185 to finish a low-level step or continue operation.  If the specified amount\n\
1186 of time passes without a response from the target, an error occurs."),
1187                             NULL,
1188                             show_watchdog,
1189                             &setlist, &showlist);
1190
1191   add_setshow_boolean_cmd ("profile", class_maintenance,
1192                            &maintenance_profile_p, _("\
1193 Set internal profiling."), _("\
1194 Show internal profiling."), _("\
1195 When enabled GDB is profiled."),
1196                            maintenance_set_profile_cmd,
1197                            show_maintenance_profile_p,
1198                            &maintenance_set_cmdlist,
1199                            &maintenance_show_cmdlist);
1200 }