Add support for v850E2 and v850E2V3
[deliverable/binutils-gdb.git] / gdb / maint.c
... / ...
CommitLineData
1/* Support for GDB maintenance commands.
2
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
4 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
6 Written by Fred Fish at Cygnus Support.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23
24#include "defs.h"
25#include "arch-utils.h"
26#include <ctype.h>
27#include <signal.h>
28#include "command.h"
29#include "gdbcmd.h"
30#include "symtab.h"
31#include "gdbtypes.h"
32#include "demangle.h"
33#include "gdbcore.h"
34#include "expression.h" /* For language.h */
35#include "language.h"
36#include "symfile.h"
37#include "objfiles.h"
38#include "value.h"
39#include "gdb_assert.h"
40
41#include "cli/cli-decode.h"
42
43extern void _initialize_maint_cmds (void);
44
45static void maintenance_command (char *, int);
46
47static void maintenance_internal_error (char *args, int from_tty);
48
49static void maintenance_demangle (char *, int);
50
51static void maintenance_time_display (char *, int);
52
53static void maintenance_space_display (char *, int);
54
55static void maintenance_info_command (char *, int);
56
57static void maintenance_info_sections (char *, int);
58
59static void maintenance_print_command (char *, int);
60
61static void maintenance_do_deprecate (char *, int);
62
63/* Set this to the maximum number of seconds to wait instead of waiting forever
64 in target_wait(). If this timer times out, then it generates an error and
65 the command is aborted. This replaces most of the need for timeouts in the
66 GDB test suite, and makes it possible to distinguish between a hung target
67 and one with slow communications. */
68
69int watchdog = 0;
70static void
71show_watchdog (struct ui_file *file, int from_tty,
72 struct cmd_list_element *c, const char *value)
73{
74 fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
75}
76
77/*
78
79 LOCAL FUNCTION
80
81 maintenance_command -- access the maintenance subcommands
82
83 SYNOPSIS
84
85 void maintenance_command (char *args, int from_tty)
86
87 DESCRIPTION
88
89 */
90
91static void
92maintenance_command (char *args, int from_tty)
93{
94 printf_unfiltered (_("\"maintenance\" must be followed by the name of a maintenance command.\n"));
95 help_list (maintenancelist, "maintenance ", -1, gdb_stdout);
96}
97
98#ifndef _WIN32
99static void
100maintenance_dump_me (char *args, int from_tty)
101{
102 if (query (_("Should GDB dump core? ")))
103 {
104#ifdef __DJGPP__
105 /* SIGQUIT by default is ignored, so use SIGABRT instead. */
106 signal (SIGABRT, SIG_DFL);
107 kill (getpid (), SIGABRT);
108#else
109 signal (SIGQUIT, SIG_DFL);
110 kill (getpid (), SIGQUIT);
111#endif
112 }
113}
114#endif
115
116/* Stimulate the internal error mechanism that GDB uses when an
117 internal problem is detected. Allows testing of the mechanism.
118 Also useful when the user wants to drop a core file but not exit
119 GDB. */
120
121static void
122maintenance_internal_error (char *args, int from_tty)
123{
124 internal_error (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
125}
126
127/* Stimulate the internal error mechanism that GDB uses when an
128 internal problem is detected. Allows testing of the mechanism.
129 Also useful when the user wants to drop a core file but not exit
130 GDB. */
131
132static void
133maintenance_internal_warning (char *args, int from_tty)
134{
135 internal_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
136}
137
138/* Someday we should allow demangling for things other than just
139 explicit strings. For example, we might want to be able to specify
140 the address of a string in either GDB's process space or the
141 debuggee's process space, and have gdb fetch and demangle that
142 string. If we have a char* pointer "ptr" that points to a string,
143 we might want to be able to given just the name and have GDB
144 demangle and print what it points to, etc. (FIXME) */
145
146static void
147maintenance_demangle (char *args, int from_tty)
148{
149 char *demangled;
150
151 if (args == NULL || *args == '\0')
152 {
153 printf_unfiltered (_("\"maintenance demangle\" takes an argument to demangle.\n"));
154 }
155 else
156 {
157 demangled = language_demangle (current_language, args,
158 DMGL_ANSI | DMGL_PARAMS);
159 if (demangled != NULL)
160 {
161 printf_unfiltered ("%s\n", demangled);
162 xfree (demangled);
163 }
164 else
165 {
166 printf_unfiltered (_("Can't demangle \"%s\"\n"), args);
167 }
168 }
169}
170
171static void
172maintenance_time_display (char *args, int from_tty)
173{
174 if (args == NULL || *args == '\0')
175 printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
176 else
177 set_display_time (strtol (args, NULL, 10));
178}
179
180static void
181maintenance_space_display (char *args, int from_tty)
182{
183 if (args == NULL || *args == '\0')
184 printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
185 else
186 set_display_space (strtol (args, NULL, 10));
187}
188
189/* The "maintenance info" command is defined as a prefix, with
190 allow_unknown 0. Therefore, its own definition is called only for
191 "maintenance info" with no args. */
192
193static void
194maintenance_info_command (char *arg, int from_tty)
195{
196 printf_unfiltered (_("\"maintenance info\" must be followed by the name of an info command.\n"));
197 help_list (maintenanceinfolist, "maintenance info ", -1, gdb_stdout);
198}
199
200/* Mini tokenizing lexer for 'maint info sections' command. */
201
202static int
203match_substring (const char *string, const char *substr)
204{
205 int substr_len = strlen(substr);
206 const char *tok;
207
208 while ((tok = strstr (string, substr)) != NULL)
209 {
210 /* Got a partial match. Is it a whole word? */
211 if (tok == string
212 || tok[-1] == ' '
213 || tok[-1] == '\t')
214 {
215 /* Token is delimited at the front... */
216 if (tok[substr_len] == ' '
217 || tok[substr_len] == '\t'
218 || tok[substr_len] == '\0')
219 {
220 /* Token is delimited at the rear. Got a whole-word match. */
221 return 1;
222 }
223 }
224 /* Token didn't match as a whole word. Advance and try again. */
225 string = tok + 1;
226 }
227 return 0;
228}
229
230static int
231match_bfd_flags (char *string, flagword flags)
232{
233 if (flags & SEC_ALLOC)
234 if (match_substring (string, "ALLOC"))
235 return 1;
236 if (flags & SEC_LOAD)
237 if (match_substring (string, "LOAD"))
238 return 1;
239 if (flags & SEC_RELOC)
240 if (match_substring (string, "RELOC"))
241 return 1;
242 if (flags & SEC_READONLY)
243 if (match_substring (string, "READONLY"))
244 return 1;
245 if (flags & SEC_CODE)
246 if (match_substring (string, "CODE"))
247 return 1;
248 if (flags & SEC_DATA)
249 if (match_substring (string, "DATA"))
250 return 1;
251 if (flags & SEC_ROM)
252 if (match_substring (string, "ROM"))
253 return 1;
254 if (flags & SEC_CONSTRUCTOR)
255 if (match_substring (string, "CONSTRUCTOR"))
256 return 1;
257 if (flags & SEC_HAS_CONTENTS)
258 if (match_substring (string, "HAS_CONTENTS"))
259 return 1;
260 if (flags & SEC_NEVER_LOAD)
261 if (match_substring (string, "NEVER_LOAD"))
262 return 1;
263 if (flags & SEC_COFF_SHARED_LIBRARY)
264 if (match_substring (string, "COFF_SHARED_LIBRARY"))
265 return 1;
266 if (flags & SEC_IS_COMMON)
267 if (match_substring (string, "IS_COMMON"))
268 return 1;
269
270 return 0;
271}
272
273static void
274print_bfd_flags (flagword flags)
275{
276 if (flags & SEC_ALLOC)
277 printf_filtered (" ALLOC");
278 if (flags & SEC_LOAD)
279 printf_filtered (" LOAD");
280 if (flags & SEC_RELOC)
281 printf_filtered (" RELOC");
282 if (flags & SEC_READONLY)
283 printf_filtered (" READONLY");
284 if (flags & SEC_CODE)
285 printf_filtered (" CODE");
286 if (flags & SEC_DATA)
287 printf_filtered (" DATA");
288 if (flags & SEC_ROM)
289 printf_filtered (" ROM");
290 if (flags & SEC_CONSTRUCTOR)
291 printf_filtered (" CONSTRUCTOR");
292 if (flags & SEC_HAS_CONTENTS)
293 printf_filtered (" HAS_CONTENTS");
294 if (flags & SEC_NEVER_LOAD)
295 printf_filtered (" NEVER_LOAD");
296 if (flags & SEC_COFF_SHARED_LIBRARY)
297 printf_filtered (" COFF_SHARED_LIBRARY");
298 if (flags & SEC_IS_COMMON)
299 printf_filtered (" IS_COMMON");
300}
301
302static void
303maint_print_section_info (const char *name, flagword flags,
304 CORE_ADDR addr, CORE_ADDR endaddr,
305 unsigned long filepos, int addr_size)
306{
307 printf_filtered (" %s", hex_string_custom (addr, addr_size));
308 printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
309 printf_filtered (" at %s",
310 hex_string_custom ((unsigned long) filepos, 8));
311 printf_filtered (": %s", name);
312 print_bfd_flags (flags);
313 printf_filtered ("\n");
314}
315
316static void
317print_bfd_section_info (bfd *abfd,
318 asection *asect,
319 void *arg)
320{
321 flagword flags = bfd_get_section_flags (abfd, asect);
322 const char *name = bfd_section_name (abfd, asect);
323
324 if (arg == NULL || *((char *) arg) == '\0'
325 || match_substring ((char *) arg, name)
326 || match_bfd_flags ((char *) arg, flags))
327 {
328 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
329 int addr_size = gdbarch_addr_bit (gdbarch) / 8;
330 CORE_ADDR addr, endaddr;
331
332 addr = bfd_section_vma (abfd, asect);
333 endaddr = addr + bfd_section_size (abfd, asect);
334 maint_print_section_info (name, flags, addr, endaddr,
335 asect->filepos, addr_size);
336 }
337}
338
339static void
340print_objfile_section_info (bfd *abfd,
341 struct obj_section *asect,
342 char *string)
343{
344 flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
345 const char *name = bfd_section_name (abfd, asect->the_bfd_section);
346
347 if (string == NULL || *string == '\0'
348 || match_substring (string, name)
349 || match_bfd_flags (string, flags))
350 {
351 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
352 int addr_size = gdbarch_addr_bit (gdbarch) / 8;
353
354 maint_print_section_info (name, flags,
355 obj_section_addr (asect),
356 obj_section_endaddr (asect),
357 asect->the_bfd_section->filepos,
358 addr_size);
359 }
360}
361
362static void
363maintenance_info_sections (char *arg, int from_tty)
364{
365 if (exec_bfd)
366 {
367 printf_filtered (_("Exec file:\n"));
368 printf_filtered (" `%s', ", bfd_get_filename (exec_bfd));
369 wrap_here (" ");
370 printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
371 if (arg && *arg && match_substring (arg, "ALLOBJ"))
372 {
373 struct objfile *ofile;
374 struct obj_section *osect;
375
376 /* Only this function cares about the 'ALLOBJ' argument;
377 if 'ALLOBJ' is the only argument, discard it rather than
378 passing it down to print_objfile_section_info (which
379 wouldn't know how to handle it). */
380 if (strcmp (arg, "ALLOBJ") == 0)
381 arg = NULL;
382
383 ALL_OBJFILES (ofile)
384 {
385 printf_filtered (_(" Object file: %s\n"),
386 bfd_get_filename (ofile->obfd));
387 ALL_OBJFILE_OSECTIONS (ofile, osect)
388 {
389 print_objfile_section_info (ofile->obfd, osect, arg);
390 }
391 }
392 }
393 else
394 bfd_map_over_sections (exec_bfd, print_bfd_section_info, arg);
395 }
396
397 if (core_bfd)
398 {
399 printf_filtered (_("Core file:\n"));
400 printf_filtered (" `%s', ", bfd_get_filename (core_bfd));
401 wrap_here (" ");
402 printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
403 bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
404 }
405}
406
407void
408maintenance_print_statistics (char *args, int from_tty)
409{
410 print_objfile_statistics ();
411 print_symbol_bcache_statistics ();
412}
413
414static void
415maintenance_print_architecture (char *args, int from_tty)
416{
417 struct gdbarch *gdbarch = get_current_arch ();
418
419 if (args == NULL)
420 gdbarch_dump (gdbarch, gdb_stdout);
421 else
422 {
423 struct cleanup *cleanups;
424 struct ui_file *file = gdb_fopen (args, "w");
425
426 if (file == NULL)
427 perror_with_name (_("maintenance print architecture"));
428 cleanups = make_cleanup_ui_file_delete (file);
429 gdbarch_dump (gdbarch, file);
430 do_cleanups (cleanups);
431 }
432}
433
434/* The "maintenance print" command is defined as a prefix, with
435 allow_unknown 0. Therefore, its own definition is called only for
436 "maintenance print" with no args. */
437
438static void
439maintenance_print_command (char *arg, int from_tty)
440{
441 printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
442 help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
443}
444
445/* The "maintenance translate-address" command converts a section and address
446 to a symbol. This can be called in two ways:
447 maintenance translate-address <secname> <addr>
448 or maintenance translate-address <addr>
449 */
450
451static void
452maintenance_translate_address (char *arg, int from_tty)
453{
454 CORE_ADDR address;
455 struct obj_section *sect;
456 char *p;
457 struct minimal_symbol *sym;
458 struct objfile *objfile;
459
460 if (arg == NULL || *arg == 0)
461 error (_("requires argument (address or section + address)"));
462
463 sect = NULL;
464 p = arg;
465
466 if (!isdigit (*p))
467 { /* See if we have a valid section name */
468 while (*p && !isspace (*p)) /* Find end of section name */
469 p++;
470 if (*p == '\000') /* End of command? */
471 error (_("Need to specify <section-name> and <address>"));
472 *p++ = '\000';
473 while (isspace (*p))
474 p++; /* Skip whitespace */
475
476 ALL_OBJSECTIONS (objfile, sect)
477 {
478 if (strcmp (sect->the_bfd_section->name, arg) == 0)
479 break;
480 }
481
482 if (!objfile)
483 error (_("Unknown section %s."), arg);
484 }
485
486 address = parse_and_eval_address (p);
487
488 if (sect)
489 sym = lookup_minimal_symbol_by_pc_section (address, sect);
490 else
491 sym = lookup_minimal_symbol_by_pc (address);
492
493 if (sym)
494 {
495 const char *symbol_name = SYMBOL_PRINT_NAME (sym);
496 const char *symbol_offset = pulongest (address - SYMBOL_VALUE_ADDRESS (sym));
497
498 sect = SYMBOL_OBJ_SECTION(sym);
499 if (sect != NULL)
500 {
501 const char *section_name;
502 const char *obj_name;
503
504 gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
505 section_name = sect->the_bfd_section->name;
506
507 gdb_assert (sect->objfile && sect->objfile->name);
508 obj_name = sect->objfile->name;
509
510 if (MULTI_OBJFILE_P ())
511 printf_filtered (_("%s + %s in section %s of %s\n"),
512 symbol_name, symbol_offset, section_name, obj_name);
513 else
514 printf_filtered (_("%s + %s in section %s\n"),
515 symbol_name, symbol_offset, section_name);
516 }
517 else
518 printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
519 }
520 else if (sect)
521 printf_filtered (_("no symbol at %s:%s\n"),
522 sect->the_bfd_section->name, hex_string (address));
523 else
524 printf_filtered (_("no symbol at %s\n"), hex_string (address));
525
526 return;
527}
528
529
530/* When a command is deprecated the user will be warned the first time
531 the command is used. If possible, a replacement will be
532 offered. */
533
534static void
535maintenance_deprecate (char *args, int from_tty)
536{
537 if (args == NULL || *args == '\0')
538 {
539 printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\
540the command you want to deprecate, and optionally the replacement command\n\
541enclosed in quotes.\n"));
542 }
543
544 maintenance_do_deprecate (args, 1);
545
546}
547
548
549static void
550maintenance_undeprecate (char *args, int from_tty)
551{
552 if (args == NULL || *args == '\0')
553 {
554 printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
555the command you want to undeprecate.\n"));
556 }
557
558 maintenance_do_deprecate (args, 0);
559
560}
561
562/* You really shouldn't be using this. It is just for the testsuite.
563 Rather, you should use deprecate_cmd() when the command is created
564 in _initialize_blah().
565
566 This function deprecates a command and optionally assigns it a
567 replacement. */
568
569static void
570maintenance_do_deprecate (char *text, int deprecate)
571{
572 struct cmd_list_element *alias = NULL;
573 struct cmd_list_element *prefix_cmd = NULL;
574 struct cmd_list_element *cmd = NULL;
575
576 char *start_ptr = NULL;
577 char *end_ptr = NULL;
578 int len;
579 char *replacement = NULL;
580
581 if (text == NULL)
582 return;
583
584 if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
585 {
586 printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
587 return;
588 }
589
590 if (deprecate)
591 {
592 /* look for a replacement command */
593 start_ptr = strchr (text, '\"');
594 if (start_ptr != NULL)
595 {
596 start_ptr++;
597 end_ptr = strrchr (start_ptr, '\"');
598 if (end_ptr != NULL)
599 {
600 len = end_ptr - start_ptr;
601 start_ptr[len] = '\0';
602 replacement = xstrdup (start_ptr);
603 }
604 }
605 }
606
607 if (!start_ptr || !end_ptr)
608 replacement = NULL;
609
610
611 /* If they used an alias, we only want to deprecate the alias.
612
613 Note the MALLOCED_REPLACEMENT test. If the command's replacement
614 string was allocated at compile time we don't want to free the
615 memory. */
616 if (alias)
617 {
618 if (alias->flags & MALLOCED_REPLACEMENT)
619 xfree (alias->replacement);
620
621 if (deprecate)
622 alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
623 else
624 alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
625 alias->replacement = replacement;
626 alias->flags |= MALLOCED_REPLACEMENT;
627 return;
628 }
629 else if (cmd)
630 {
631 if (cmd->flags & MALLOCED_REPLACEMENT)
632 xfree (cmd->replacement);
633
634 if (deprecate)
635 cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
636 else
637 cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
638 cmd->replacement = replacement;
639 cmd->flags |= MALLOCED_REPLACEMENT;
640 return;
641 }
642}
643
644/* Maintenance set/show framework. */
645
646struct cmd_list_element *maintenance_set_cmdlist;
647struct cmd_list_element *maintenance_show_cmdlist;
648
649static void
650maintenance_set_cmd (char *args, int from_tty)
651{
652 printf_unfiltered (_("\"maintenance set\" must be followed by the name of a set command.\n"));
653 help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
654}
655
656static void
657maintenance_show_cmd (char *args, int from_tty)
658{
659 cmd_show_list (maintenance_show_cmdlist, from_tty, "");
660}
661
662/* Profiling support. */
663
664static int maintenance_profile_p;
665static void
666show_maintenance_profile_p (struct ui_file *file, int from_tty,
667 struct cmd_list_element *c, const char *value)
668{
669 fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
670}
671
672#ifdef HAVE__ETEXT
673extern char _etext;
674#define TEXTEND &_etext
675#elif defined (HAVE_ETEXT)
676extern char etext;
677#define TEXTEND &etext
678#endif
679
680#if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
681
682static int profiling_state;
683
684static void
685mcleanup_wrapper (void)
686{
687 extern void _mcleanup (void);
688
689 if (profiling_state)
690 _mcleanup ();
691}
692
693static void
694maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
695{
696 if (maintenance_profile_p == profiling_state)
697 return;
698
699 profiling_state = maintenance_profile_p;
700
701 if (maintenance_profile_p)
702 {
703 static int profiling_initialized;
704
705 extern void monstartup (unsigned long, unsigned long);
706 extern int main();
707
708 if (!profiling_initialized)
709 {
710 atexit (mcleanup_wrapper);
711 profiling_initialized = 1;
712 }
713
714 /* "main" is now always the first function in the text segment, so use
715 its address for monstartup. */
716 monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
717 }
718 else
719 {
720 extern void _mcleanup (void);
721
722 _mcleanup ();
723 }
724}
725#else
726static void
727maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
728{
729 error (_("Profiling support is not available on this system."));
730}
731#endif
732
733void
734_initialize_maint_cmds (void)
735{
736 add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
737Commands for use by GDB maintainers.\n\
738Includes commands to dump specific internal GDB structures in\n\
739a human readable form, to cause GDB to deliberately dump core,\n\
740to test internal functions such as the C++/ObjC demangler, etc."),
741 &maintenancelist, "maintenance ", 0,
742 &cmdlist);
743
744 add_com_alias ("mt", "maintenance", class_maintenance, 1);
745
746 add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
747Commands for showing internal info about the program being debugged."),
748 &maintenanceinfolist, "maintenance info ", 0,
749 &maintenancelist);
750 add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
751
752 add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
753List the BFD sections of the exec and core files. \n\
754Arguments may be any combination of:\n\
755 [one or more section names]\n\
756 ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
757 HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
758Sections matching any argument will be listed (no argument\n\
759implies all sections). In addition, the special argument\n\
760 ALLOBJ\n\
761lists all sections from all object files, including shared libraries."),
762 &maintenanceinfolist);
763
764 add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
765 _("Maintenance command for printing GDB internal state."),
766 &maintenanceprintlist, "maintenance print ", 0,
767 &maintenancelist);
768
769 add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
770Set GDB internal variables used by the GDB maintainer.\n\
771Configure variables internal to GDB that aid in GDB's maintenance"),
772 &maintenance_set_cmdlist, "maintenance set ",
773 0/*allow-unknown*/,
774 &maintenancelist);
775
776 add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
777Show GDB internal variables used by the GDB maintainer.\n\
778Configure variables internal to GDB that aid in GDB's maintenance"),
779 &maintenance_show_cmdlist, "maintenance show ",
780 0/*allow-unknown*/,
781 &maintenancelist);
782
783#ifndef _WIN32
784 add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
785Get fatal error; make debugger dump its core.\n\
786GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
787itself a SIGQUIT signal."),
788 &maintenancelist);
789#endif
790
791 add_cmd ("internal-error", class_maintenance,
792 maintenance_internal_error, _("\
793Give GDB an internal error.\n\
794Cause GDB to behave as if an internal error was detected."),
795 &maintenancelist);
796
797 add_cmd ("internal-warning", class_maintenance,
798 maintenance_internal_warning, _("\
799Give GDB an internal warning.\n\
800Cause GDB to behave as if an internal warning was reported."),
801 &maintenancelist);
802
803 add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
804Demangle a C++/ObjC mangled name.\n\
805Call internal GDB demangler routine to demangle a C++ link name\n\
806and prints the result."),
807 &maintenancelist);
808
809 add_cmd ("time", class_maintenance, maintenance_time_display, _("\
810Set the display of time usage.\n\
811If nonzero, will cause the execution time for each command to be\n\
812displayed, following the command's output."),
813 &maintenancelist);
814
815 add_cmd ("space", class_maintenance, maintenance_space_display, _("\
816Set the display of space usage.\n\
817If nonzero, will cause the execution space for each command to be\n\
818displayed, following the command's output."),
819 &maintenancelist);
820
821 add_cmd ("type", class_maintenance, maintenance_print_type, _("\
822Print a type chain for a given symbol.\n\
823For each node in a type chain, print the raw data for each member of\n\
824the type structure, and the interpretation of the data."),
825 &maintenanceprintlist);
826
827 add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
828Print dump of current symbol definitions.\n\
829Entries in the full symbol table are dumped to file OUTFILE.\n\
830If a SOURCE file is specified, dump only that file's symbols."),
831 &maintenanceprintlist);
832
833 add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
834Print dump of current minimal symbol definitions.\n\
835Entries in the minimal symbol table are dumped to file OUTFILE.\n\
836If a SOURCE file is specified, dump only that file's minimal symbols."),
837 &maintenanceprintlist);
838
839 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
840Print dump of current partial symbol definitions.\n\
841Entries in the partial symbol table are dumped to file OUTFILE.\n\
842If a SOURCE file is specified, dump only that file's partial symbols."),
843 &maintenanceprintlist);
844
845 add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
846 _("Print dump of current object file definitions."),
847 &maintenanceprintlist);
848
849 add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
850List the full symbol tables for all object files.\n\
851This does not include information about individual symbols, blocks, or\n\
852linetables --- just the symbol table structures themselves.\n\
853With an argument REGEXP, list the symbol tables whose names that match that."),
854 &maintenanceinfolist);
855
856 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
857List the partial symbol tables for all object files.\n\
858This does not include information about individual partial symbols,\n\
859just the symbol table structures themselves."),
860 &maintenanceinfolist);
861
862 add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
863 _("Print statistics about internal gdb state."),
864 &maintenanceprintlist);
865
866 add_cmd ("architecture", class_maintenance,
867 maintenance_print_architecture, _("\
868Print the internal architecture configuration.\n\
869Takes an optional file parameter."),
870 &maintenanceprintlist);
871
872 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
873 _("Check consistency of psymtabs and symtabs."),
874 &maintenancelist);
875
876 add_cmd ("translate-address", class_maintenance, maintenance_translate_address,
877 _("Translate a section name and address to a symbol."),
878 &maintenancelist);
879
880 add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
881Deprecate a command. Note that this is just in here so the \n\
882testsuite can check the command deprecator. You probably shouldn't use this,\n\
883rather you should use the C function deprecate_cmd(). If you decide you \n\
884want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
885replacement is optional."), &maintenancelist);
886
887 add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
888Undeprecate a command. Note that this is just in here so the \n\
889testsuite can check the command deprecator. You probably shouldn't use this,\n\
890If you decide you want to use it: maintenance undeprecate 'commandname'"),
891 &maintenancelist);
892
893 add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
894Set watchdog timer."), _("\
895Show watchdog timer."), _("\
896When non-zero, this timeout is used instead of waiting forever for a target\n\
897to finish a low-level step or continue operation. If the specified amount\n\
898of time passes without a response from the target, an error occurs."),
899 NULL,
900 show_watchdog,
901 &setlist, &showlist);
902
903 add_setshow_boolean_cmd ("profile", class_maintenance,
904 &maintenance_profile_p, _("\
905Set internal profiling."), _("\
906Show internal profiling."), _("\
907When enabled GDB is profiled."),
908 maintenance_set_profile_cmd,
909 show_maintenance_profile_p,
910 &maintenance_set_cmdlist,
911 &maintenance_show_cmdlist);
912}
This page took 0.037201 seconds and 4 git commands to generate.