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