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