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