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