1 /* Support for GDB maintenance commands. 2 3 Copyright (C) 1992-1997, 1999-2004, 2007-2012 Free Software 4 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 /* 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 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 while (isspace (*p)) 465 p++; /* Skip whitespace. */ 466 467 ALL_OBJSECTIONS (objfile, sect) 468 { 469 if (strcmp (sect->the_bfd_section->name, arg) == 0) 470 break; 471 } 472 473 if (!objfile) 474 error (_("Unknown section %s."), arg); 475 } 476 477 address = parse_and_eval_address (p); 478 479 if (sect) 480 sym = lookup_minimal_symbol_by_pc_section (address, sect); 481 else 482 sym = lookup_minimal_symbol_by_pc (address); 483 484 if (sym) 485 { 486 const char *symbol_name = SYMBOL_PRINT_NAME (sym); 487 const char *symbol_offset 488 = pulongest (address - SYMBOL_VALUE_ADDRESS (sym)); 489 490 sect = SYMBOL_OBJ_SECTION(sym); 491 if (sect != NULL) 492 { 493 const char *section_name; 494 const char *obj_name; 495 496 gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name); 497 section_name = sect->the_bfd_section->name; 498 499 gdb_assert (sect->objfile && sect->objfile->name); 500 obj_name = sect->objfile->name; 501 502 if (MULTI_OBJFILE_P ()) 503 printf_filtered (_("%s + %s in section %s of %s\n"), 504 symbol_name, symbol_offset, 505 section_name, obj_name); 506 else 507 printf_filtered (_("%s + %s in section %s\n"), 508 symbol_name, symbol_offset, section_name); 509 } 510 else 511 printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset); 512 } 513 else if (sect) 514 printf_filtered (_("no symbol at %s:%s\n"), 515 sect->the_bfd_section->name, hex_string (address)); 516 else 517 printf_filtered (_("no symbol at %s\n"), hex_string (address)); 518 519 return; 520 } 521 522 523 /* When a command is deprecated the user will be warned the first time 524 the command is used. If possible, a replacement will be 525 offered. */ 526 527 static void 528 maintenance_deprecate (char *args, int from_tty) 529 { 530 if (args == NULL || *args == '\0') 531 { 532 printf_unfiltered (_("\"maintenance deprecate\" takes an argument,\n\ 533 the command you want to deprecate, and optionally the replacement command\n\ 534 enclosed in quotes.\n")); 535 } 536 537 maintenance_do_deprecate (args, 1); 538 539 } 540 541 542 static void 543 maintenance_undeprecate (char *args, int from_tty) 544 { 545 if (args == NULL || *args == '\0') 546 { 547 printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\ 548 the command you want to undeprecate.\n")); 549 } 550 551 maintenance_do_deprecate (args, 0); 552 553 } 554 555 /* You really shouldn't be using this. It is just for the testsuite. 556 Rather, you should use deprecate_cmd() when the command is created 557 in _initialize_blah(). 558 559 This function deprecates a command and optionally assigns it a 560 replacement. */ 561 562 static void 563 maintenance_do_deprecate (char *text, int deprecate) 564 { 565 struct cmd_list_element *alias = NULL; 566 struct cmd_list_element *prefix_cmd = NULL; 567 struct cmd_list_element *cmd = NULL; 568 569 char *start_ptr = NULL; 570 char *end_ptr = NULL; 571 int len; 572 char *replacement = NULL; 573 574 if (text == NULL) 575 return; 576 577 if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd)) 578 { 579 printf_filtered (_("Can't find command '%s' to deprecate.\n"), text); 580 return; 581 } 582 583 if (deprecate) 584 { 585 /* Look for a replacement command. */ 586 start_ptr = strchr (text, '\"'); 587 if (start_ptr != NULL) 588 { 589 start_ptr++; 590 end_ptr = strrchr (start_ptr, '\"'); 591 if (end_ptr != NULL) 592 { 593 len = end_ptr - start_ptr; 594 start_ptr[len] = '\0'; 595 replacement = xstrdup (start_ptr); 596 } 597 } 598 } 599 600 if (!start_ptr || !end_ptr) 601 replacement = NULL; 602 603 604 /* If they used an alias, we only want to deprecate the alias. 605 606 Note the MALLOCED_REPLACEMENT test. If the command's replacement 607 string was allocated at compile time we don't want to free the 608 memory. */ 609 if (alias) 610 { 611 if (alias->flags & MALLOCED_REPLACEMENT) 612 xfree (alias->replacement); 613 614 if (deprecate) 615 alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED); 616 else 617 alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED); 618 alias->replacement = replacement; 619 alias->flags |= MALLOCED_REPLACEMENT; 620 return; 621 } 622 else if (cmd) 623 { 624 if (cmd->flags & MALLOCED_REPLACEMENT) 625 xfree (cmd->replacement); 626 627 if (deprecate) 628 cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED); 629 else 630 cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED); 631 cmd->replacement = replacement; 632 cmd->flags |= MALLOCED_REPLACEMENT; 633 return; 634 } 635 xfree (replacement); 636 } 637 638 /* Maintenance set/show framework. */ 639 640 struct cmd_list_element *maintenance_set_cmdlist; 641 struct cmd_list_element *maintenance_show_cmdlist; 642 643 static void 644 maintenance_set_cmd (char *args, int from_tty) 645 { 646 printf_unfiltered (_("\"maintenance set\" must be followed " 647 "by the name of a set command.\n")); 648 help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout); 649 } 650 651 static void 652 maintenance_show_cmd (char *args, int from_tty) 653 { 654 cmd_show_list (maintenance_show_cmdlist, from_tty, ""); 655 } 656 657 /* Profiling support. */ 658 659 static int maintenance_profile_p; 660 static void 661 show_maintenance_profile_p (struct ui_file *file, int from_tty, 662 struct cmd_list_element *c, const char *value) 663 { 664 fprintf_filtered (file, _("Internal profiling is %s.\n"), value); 665 } 666 667 #ifdef HAVE__ETEXT 668 extern char _etext; 669 #define TEXTEND &_etext 670 #elif defined (HAVE_ETEXT) 671 extern char etext; 672 #define TEXTEND &etext 673 #endif 674 675 #if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND) 676 677 static int profiling_state; 678 679 static void 680 mcleanup_wrapper (void) 681 { 682 extern void _mcleanup (void); 683 684 if (profiling_state) 685 _mcleanup (); 686 } 687 688 static void 689 maintenance_set_profile_cmd (char *args, int from_tty, 690 struct cmd_list_element *c) 691 { 692 if (maintenance_profile_p == profiling_state) 693 return; 694 695 profiling_state = maintenance_profile_p; 696 697 if (maintenance_profile_p) 698 { 699 static int profiling_initialized; 700 701 extern void monstartup (unsigned long, unsigned long); 702 extern int main(); 703 704 if (!profiling_initialized) 705 { 706 atexit (mcleanup_wrapper); 707 profiling_initialized = 1; 708 } 709 710 /* "main" is now always the first function in the text segment, so use 711 its address for monstartup. */ 712 monstartup ((unsigned long) &main, (unsigned long) TEXTEND); 713 } 714 else 715 { 716 extern void _mcleanup (void); 717 718 _mcleanup (); 719 } 720 } 721 #else 722 static void 723 maintenance_set_profile_cmd (char *args, int from_tty, 724 struct cmd_list_element *c) 725 { 726 error (_("Profiling support is not available on this system.")); 727 } 728 #endif 729 730 void 731 _initialize_maint_cmds (void) 732 { 733 add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\ 734 Commands for use by GDB maintainers.\n\ 735 Includes commands to dump specific internal GDB structures in\n\ 736 a human readable form, to cause GDB to deliberately dump core,\n\ 737 to test internal functions such as the C++/ObjC demangler, etc."), 738 &maintenancelist, "maintenance ", 0, 739 &cmdlist); 740 741 add_com_alias ("mt", "maintenance", class_maintenance, 1); 742 743 add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\ 744 Commands for showing internal info about the program being debugged."), 745 &maintenanceinfolist, "maintenance info ", 0, 746 &maintenancelist); 747 add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist); 748 749 add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\ 750 List the BFD sections of the exec and core files. \n\ 751 Arguments may be any combination of:\n\ 752 [one or more section names]\n\ 753 ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\ 754 HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\ 755 Sections matching any argument will be listed (no argument\n\ 756 implies all sections). In addition, the special argument\n\ 757 ALLOBJ\n\ 758 lists all sections from all object files, including shared libraries."), 759 &maintenanceinfolist); 760 761 add_prefix_cmd ("print", class_maintenance, maintenance_print_command, 762 _("Maintenance command for printing GDB internal state."), 763 &maintenanceprintlist, "maintenance print ", 0, 764 &maintenancelist); 765 766 add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\ 767 Set GDB internal variables used by the GDB maintainer.\n\ 768 Configure variables internal to GDB that aid in GDB's maintenance"), 769 &maintenance_set_cmdlist, "maintenance set ", 770 0/*allow-unknown*/, 771 &maintenancelist); 772 773 add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\ 774 Show GDB internal variables used by the GDB maintainer.\n\ 775 Configure variables internal to GDB that aid in GDB's maintenance"), 776 &maintenance_show_cmdlist, "maintenance show ", 777 0/*allow-unknown*/, 778 &maintenancelist); 779 780 #ifndef _WIN32 781 add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\ 782 Get fatal error; make debugger dump its core.\n\ 783 GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\ 784 itself a SIGQUIT signal."), 785 &maintenancelist); 786 #endif 787 788 add_cmd ("internal-error", class_maintenance, 789 maintenance_internal_error, _("\ 790 Give GDB an internal error.\n\ 791 Cause GDB to behave as if an internal error was detected."), 792 &maintenancelist); 793 794 add_cmd ("internal-warning", class_maintenance, 795 maintenance_internal_warning, _("\ 796 Give GDB an internal warning.\n\ 797 Cause GDB to behave as if an internal warning was reported."), 798 &maintenancelist); 799 800 add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\ 801 Demangle a C++/ObjC mangled name.\n\ 802 Call internal GDB demangler routine to demangle a C++ link name\n\ 803 and prints the result."), 804 &maintenancelist); 805 806 add_cmd ("time", class_maintenance, maintenance_time_display, _("\ 807 Set the display of time usage.\n\ 808 If nonzero, will cause the execution time for each command to be\n\ 809 displayed, following the command's output."), 810 &maintenancelist); 811 812 add_cmd ("space", class_maintenance, maintenance_space_display, _("\ 813 Set the display of space usage.\n\ 814 If nonzero, will cause the execution space for each command to be\n\ 815 displayed, following the command's output."), 816 &maintenancelist); 817 818 add_cmd ("type", class_maintenance, maintenance_print_type, _("\ 819 Print a type chain for a given symbol.\n\ 820 For each node in a type chain, print the raw data for each member of\n\ 821 the type structure, and the interpretation of the data."), 822 &maintenanceprintlist); 823 824 add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\ 825 Print dump of current symbol definitions.\n\ 826 Entries in the full symbol table are dumped to file OUTFILE.\n\ 827 If a SOURCE file is specified, dump only that file's symbols."), 828 &maintenanceprintlist); 829 830 add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\ 831 Print dump of current minimal symbol definitions.\n\ 832 Entries in the minimal symbol table are dumped to file OUTFILE.\n\ 833 If a SOURCE file is specified, dump only that file's minimal symbols."), 834 &maintenanceprintlist); 835 836 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\ 837 Print dump of current partial symbol definitions.\n\ 838 Entries in the partial symbol table are dumped to file OUTFILE.\n\ 839 If a SOURCE file is specified, dump only that file's partial symbols."), 840 &maintenanceprintlist); 841 842 add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles, 843 _("Print dump of current object file definitions."), 844 &maintenanceprintlist); 845 846 add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\ 847 List the full symbol tables for all object files.\n\ 848 This does not include information about individual symbols, blocks, or\n\ 849 linetables --- just the symbol table structures themselves.\n\ 850 With an argument REGEXP, list the symbol tables whose names that match that."), 851 &maintenanceinfolist); 852 853 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\ 854 List the partial symbol tables for all object files.\n\ 855 This does not include information about individual partial symbols,\n\ 856 just the symbol table structures themselves."), 857 &maintenanceinfolist); 858 859 add_cmd ("statistics", class_maintenance, maintenance_print_statistics, 860 _("Print statistics about internal gdb state."), 861 &maintenanceprintlist); 862 863 add_cmd ("architecture", class_maintenance, 864 maintenance_print_architecture, _("\ 865 Print the internal architecture configuration.\n\ 866 Takes an optional file parameter."), 867 &maintenanceprintlist); 868 869 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs, 870 _("Check consistency of psymtabs and symtabs."), 871 &maintenancelist); 872 873 add_cmd ("translate-address", class_maintenance, 874 maintenance_translate_address, 875 _("Translate a section name and address to a symbol."), 876 &maintenancelist); 877 878 add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\ 879 Deprecate a command. Note that this is just in here so the \n\ 880 testsuite can check the command deprecator. You probably shouldn't use this,\n\ 881 rather you should use the C function deprecate_cmd(). If you decide you \n\ 882 want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\ 883 replacement is optional."), &maintenancelist); 884 885 add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\ 886 Undeprecate 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 If you decide you want to use it: maintenance undeprecate 'commandname'"), 889 &maintenancelist); 890 891 add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\ 892 Set watchdog timer."), _("\ 893 Show watchdog timer."), _("\ 894 When non-zero, this timeout is used instead of waiting forever for a target\n\ 895 to finish a low-level step or continue operation. If the specified amount\n\ 896 of time passes without a response from the target, an error occurs."), 897 NULL, 898 show_watchdog, 899 &setlist, &showlist); 900 901 add_setshow_boolean_cmd ("profile", class_maintenance, 902 &maintenance_profile_p, _("\ 903 Set internal profiling."), _("\ 904 Show internal profiling."), _("\ 905 When enabled GDB is profiled."), 906 maintenance_set_profile_cmd, 907 show_maintenance_profile_p, 908 &maintenance_set_cmdlist, 909 &maintenance_show_cmdlist); 910 } 911