X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsymmisc.c;h=d5efcfd2409a056418c8ddd6a6784e739dc3021b;hb=f3abeff575541dd80e1facd6d0f920e10f77fede;hp=52c934ab536313b79a35df32c35a40aca51dbc2f;hpb=4c8429eff1e1d9e511b227b6ea0b15c06c376e30;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symmisc.c b/gdb/symmisc.c index 52c934ab53..d5efcfd240 100644 --- a/gdb/symmisc.c +++ b/gdb/symmisc.c @@ -1,6 +1,6 @@ /* Do various things to symbol tables (other than lookup), for GDB. - Copyright (C) 1986-2013 Free Software Foundation, Inc. + Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -27,18 +27,15 @@ #include "breakpoint.h" #include "command.h" #include "gdb_obstack.h" -#include "exceptions.h" #include "language.h" #include "bcache.h" #include "block.h" #include "gdb_regex.h" -#include "gdb_stat.h" +#include #include "dictionary.h" #include "typeprint.h" #include "gdbcmd.h" #include "source.h" - -#include "gdb_string.h" #include "readline/readline.h" #include "psymtab.h" @@ -59,13 +56,6 @@ FILE *std_err; /* Prototypes for local functions */ -static void dump_symtab (struct objfile *, struct symtab *, - struct ui_file *); - -static void dump_msymbols (struct objfile *, struct ui_file *); - -static void dump_objfile (struct objfile *); - static int block_depth (struct block *); void _initialize_symmisc (void); @@ -91,7 +81,8 @@ print_symbol_bcache_statistics (void) ALL_PSPACE_OBJFILES (pspace, objfile) { QUIT; - printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name); + printf_filtered (_("Byte cache statistics for '%s':\n"), + objfile_name (objfile)); print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache), "partial symbol cache"); print_bcache_statistics (objfile->per_bfd->macro_cache, @@ -106,6 +97,7 @@ print_objfile_statistics (void) { struct program_space *pspace; struct objfile *objfile; + struct compunit_symtab *cu; struct symtab *s; int i, linetables, blockvectors; @@ -113,13 +105,13 @@ print_objfile_statistics (void) ALL_PSPACE_OBJFILES (pspace, objfile) { QUIT; - printf_filtered (_("Statistics for '%s':\n"), objfile->name); + printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile)); if (OBJSTAT (objfile, n_stabs) > 0) printf_filtered (_(" Number of \"stab\" symbols read: %d\n"), OBJSTAT (objfile, n_stabs)); - if (OBJSTAT (objfile, n_minsyms) > 0) + if (objfile->per_bfd->n_minsyms > 0) printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"), - OBJSTAT (objfile, n_minsyms)); + objfile->per_bfd->n_minsyms); if (OBJSTAT (objfile, n_psyms) > 0) printf_filtered (_(" Number of \"partial\" symbols read: %d\n"), OBJSTAT (objfile, n_psyms)); @@ -132,27 +124,29 @@ print_objfile_statistics (void) if (objfile->sf) objfile->sf->qf->print_stats (objfile); i = linetables = blockvectors = 0; - ALL_OBJFILE_SYMTABS (objfile, s) + ALL_OBJFILE_FILETABS (objfile, cu, s) { i++; - if (s->linetable != NULL) + if (SYMTAB_LINETABLE (s) != NULL) linetables++; - if (s->primary == 1) - blockvectors++; } + ALL_OBJFILE_COMPUNITS (objfile, cu) + blockvectors++; printf_filtered (_(" Number of symbol tables: %d\n"), i); - printf_filtered (_(" Number of symbol tables with line tables: %d\n"), + printf_filtered (_(" Number of symbol tables with line tables: %d\n"), linetables); - printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"), + printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"), blockvectors); - + if (OBJSTAT (objfile, sz_strtab) > 0) printf_filtered (_(" Space used by a.out string tables: %d\n"), OBJSTAT (objfile, sz_strtab)); - printf_filtered (_(" Total memory used for objfile obstack: %d\n"), - obstack_memory_used (&objfile->objfile_obstack)); - printf_filtered (_(" Total memory used for BFD obstack: %d\n"), - obstack_memory_used (&objfile->per_bfd->storage_obstack)); + printf_filtered (_(" Total memory used for objfile obstack: %s\n"), + pulongest (obstack_memory_used (&objfile + ->objfile_obstack))); + printf_filtered (_(" Total memory used for BFD obstack: %s\n"), + pulongest (obstack_memory_used (&objfile->per_bfd + ->storage_obstack))); printf_filtered (_(" Total memory used for psymbol cache: %d\n"), bcache_memory_used (psymbol_bcache_get_bcache (objfile->psymbol_cache))); @@ -166,30 +160,29 @@ print_objfile_statistics (void) static void dump_objfile (struct objfile *objfile) { + struct compunit_symtab *cust; struct symtab *symtab; - printf_filtered ("\nObject file %s: ", objfile->name); + printf_filtered ("\nObject file %s: ", objfile_name (objfile)); printf_filtered ("Objfile at "); gdb_print_host_address (objfile, gdb_stdout); printf_filtered (", bfd at "); gdb_print_host_address (objfile->obfd, gdb_stdout); printf_filtered (", %d minsyms\n\n", - objfile->minimal_symbol_count); + objfile->per_bfd->minimal_symbol_count); if (objfile->sf) objfile->sf->qf->dump (objfile); - if (objfile->symtabs) + if (objfile->compunit_symtabs != NULL) { printf_filtered ("Symtabs:\n"); - for (symtab = objfile->symtabs; - symtab != NULL; - symtab = symtab->next) + ALL_OBJFILE_FILETABS (objfile, cust, symtab) { printf_filtered ("%s at ", symtab_to_filename_for_display (symtab)); gdb_print_host_address (symtab, gdb_stdout); printf_filtered (", "); - if (symtab->objfile != objfile) + if (SYMTAB_OBJFILE (symtab) != objfile) { printf_filtered ("NOT ON CHAIN! "); } @@ -209,8 +202,8 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile) int index; char ms_type; - fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name); - if (objfile->minimal_symbol_count == 0) + fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile)); + if (objfile->per_bfd->minimal_symbol_count == 0) { fprintf_filtered (outfile, "No minimal symbols found.\n"); return; @@ -218,7 +211,7 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile) index = 0; ALL_OBJFILE_MSYMBOLS (objfile, msymbol) { - struct obj_section *section = SYMBOL_OBJ_SECTION (objfile, msymbol); + struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol); switch (MSYMBOL_TYPE (msymbol)) { @@ -257,9 +250,10 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile) break; } fprintf_filtered (outfile, "[%2d] %c ", index, ms_type); - fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)), + fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile, + msymbol)), outfile); - fprintf_filtered (outfile, " %s", SYMBOL_LINKAGE_NAME (msymbol)); + fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol)); if (section) { if (section->the_bfd_section != NULL) @@ -270,50 +264,51 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile) fprintf_filtered (outfile, " spurious section %ld", (long) (section - objfile->sections)); } - if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL) + if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL) { - fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol)); + fprintf_filtered (outfile, " %s", MSYMBOL_DEMANGLED_NAME (msymbol)); } if (msymbol->filename) fprintf_filtered (outfile, " %s", msymbol->filename); fputs_filtered ("\n", outfile); index++; } - if (objfile->minimal_symbol_count != index) + if (objfile->per_bfd->minimal_symbol_count != index) { warning (_("internal error: minimal symbol count %d != %d"), - objfile->minimal_symbol_count, index); + objfile->per_bfd->minimal_symbol_count, index); } fprintf_filtered (outfile, "\n"); } static void -dump_symtab_1 (struct objfile *objfile, struct symtab *symtab, - struct ui_file *outfile) +dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile) { + struct objfile *objfile = SYMTAB_OBJFILE (symtab); struct gdbarch *gdbarch = get_objfile_arch (objfile); int i; struct dict_iterator iter; int len; struct linetable *l; - struct blockvector *bv; + const struct blockvector *bv; struct symbol *sym; struct block *b; int depth; fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab_to_filename_for_display (symtab)); - if (symtab->dirname) + if (SYMTAB_DIRNAME (symtab) != NULL) fprintf_filtered (outfile, "Compilation directory is %s\n", - symtab->dirname); - fprintf_filtered (outfile, "Read from object file %s (", objfile->name); + SYMTAB_DIRNAME (symtab)); + fprintf_filtered (outfile, "Read from object file %s (", + objfile_name (objfile)); gdb_print_host_address (objfile, outfile); fprintf_filtered (outfile, ")\n"); fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language)); /* First print the line table. */ - l = LINETABLE (symtab); + l = SYMTAB_LINETABLE (symtab); if (l) { fprintf_filtered (outfile, "\nLine table:\n\n"); @@ -325,12 +320,12 @@ dump_symtab_1 (struct objfile *objfile, struct symtab *symtab, fprintf_filtered (outfile, "\n"); } } - /* Now print the block info, but only for primary symtabs since we will + /* Now print the block info, but only for compunit symtabs since we will print lots of duplicate info otherwise. */ - if (symtab->primary) + if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab))) { fprintf_filtered (outfile, "\nBlockvector:\n\n"); - bv = BLOCKVECTOR (symtab); + bv = SYMTAB_BLOCKVECTOR (symtab); len = BLOCKVECTOR_NBLOCKS (bv); for (i = 0; i < len; i++) { @@ -382,13 +377,17 @@ dump_symtab_1 (struct objfile *objfile, struct symtab *symtab, } else { - fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n"); + const char *compunit_filename + = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab))); + + fprintf_filtered (outfile, + "\nBlockvector same as owning compunit: %s\n\n", + compunit_filename); } } static void -dump_symtab (struct objfile *objfile, struct symtab *symtab, - struct ui_file *outfile) +dump_symtab (struct symtab *symtab, struct ui_file *outfile) { /* Set the current language to the language of the symtab we're dumping because certain routines used during dump_symtab() use the current @@ -401,12 +400,12 @@ dump_symtab (struct objfile *objfile, struct symtab *symtab, saved_lang = set_language (symtab->language); - dump_symtab_1 (objfile, symtab, outfile); + dump_symtab_1 (symtab, outfile); set_language (saved_lang); } else - dump_symtab_1 (objfile, symtab, outfile); + dump_symtab_1 (symtab, outfile); } static void @@ -418,6 +417,7 @@ maintenance_print_symbols (char *args, int from_tty) char *symname = NULL; char *filename = DEV_TTY; struct objfile *objfile; + struct compunit_symtab *cu; struct symtab *s; dont_repeat (); @@ -448,12 +448,12 @@ maintenance_print_symbols (char *args, int from_tty) perror_with_name (filename); make_cleanup_ui_file_delete (outfile); - ALL_SYMTABS (objfile, s) + ALL_FILETABS (objfile, cu, s) { QUIT; if (symname == NULL || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0) - dump_symtab (objfile, s, outfile); + dump_symtab (s, outfile); } do_cleanups (cleanups); } @@ -470,8 +470,12 @@ print_symbol (void *args) struct symbol *symbol = ((struct print_symbol_args *) args)->symbol; int depth = ((struct print_symbol_args *) args)->depth; struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile; - struct obj_section *section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (symbol), - symbol); + struct obj_section *section; + + if (SYMBOL_OBJFILE_OWNED (symbol)) + section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol); + else + section = NULL; print_spaces (depth, outfile); if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN) @@ -684,7 +688,7 @@ maintenance_print_msymbols (char *args, int from_tty) ALL_PSPACE_OBJFILES (pspace, objfile) { QUIT; - if (symname == NULL || (!stat (objfile->name, &obj_st) + if (symname == NULL || (!stat (objfile_name (objfile), &obj_st) && sym_st.st_dev == obj_st.st_dev && sym_st.st_ino == obj_st.st_ino)) dump_msymbols (objfile, outfile); @@ -694,18 +698,23 @@ maintenance_print_msymbols (char *args, int from_tty) } static void -maintenance_print_objfiles (char *ignore, int from_tty) +maintenance_print_objfiles (char *regexp, int from_tty) { struct program_space *pspace; struct objfile *objfile; dont_repeat (); + if (regexp) + re_comp (regexp); + ALL_PSPACES (pspace) ALL_PSPACE_OBJFILES (pspace, objfile) { QUIT; - dump_objfile (objfile); + if (! regexp + || re_exec (objfile_name (objfile))) + dump_objfile (objfile); } } @@ -717,53 +726,135 @@ maintenance_info_symtabs (char *regexp, int from_tty) struct program_space *pspace; struct objfile *objfile; + dont_repeat (); + if (regexp) re_comp (regexp); ALL_PSPACES (pspace) ALL_PSPACE_OBJFILES (pspace, objfile) { + struct compunit_symtab *cust; struct symtab *symtab; - + /* We don't want to print anything for this objfile until we actually find a symtab whose name matches. */ int printed_objfile_start = 0; - ALL_OBJFILE_SYMTABS (objfile, symtab) + ALL_OBJFILE_COMPUNITS (objfile, cust) + { + int printed_compunit_symtab_start = 0; + + ALL_COMPUNIT_FILETABS (cust, symtab) + { + QUIT; + + if (! regexp + || re_exec (symtab_to_filename_for_display (symtab))) + { + if (! printed_objfile_start) + { + printf_filtered ("{ objfile %s ", objfile_name (objfile)); + wrap_here (" "); + printf_filtered ("((struct objfile *) %s)\n", + host_address_to_string (objfile)); + printed_objfile_start = 1; + } + if (! printed_compunit_symtab_start) + { + printf_filtered (" { ((struct compunit_symtab *) %s)\n", + host_address_to_string (cust)); + printf_filtered (" debugformat %s\n", + COMPUNIT_DEBUGFORMAT (cust)); + printf_filtered (" producer %s\n", + COMPUNIT_PRODUCER (cust) != NULL + ? COMPUNIT_PRODUCER (cust) + : "(null)"); + printf_filtered (" dirname %s\n", + COMPUNIT_DIRNAME (cust) != NULL + ? COMPUNIT_DIRNAME (cust) + : "(null)"); + printf_filtered (" blockvector" + " ((struct blockvector *) %s)\n", + host_address_to_string + (COMPUNIT_BLOCKVECTOR (cust))); + printed_compunit_symtab_start = 1; + } + + printf_filtered ("\t{ symtab %s ", + symtab_to_filename_for_display (symtab)); + wrap_here (" "); + printf_filtered ("((struct symtab *) %s)\n", + host_address_to_string (symtab)); + printf_filtered ("\t fullname %s\n", + symtab->fullname != NULL + ? symtab->fullname + : "(null)"); + printf_filtered ("\t " + "linetable ((struct linetable *) %s)\n", + host_address_to_string (symtab->linetable)); + printf_filtered ("\t}\n"); + } + } + + if (printed_compunit_symtab_start) + printf_filtered (" }\n"); + } + + if (printed_objfile_start) + printf_filtered ("}\n"); + } +} + +/* Check consistency of symtabs. + An example of what this checks for is NULL blockvectors. + They can happen if there's a bug during debug info reading. + GDB assumes they are always non-NULL. + + Note: This does not check for psymtab vs symtab consistency. + Use "maint check-psymtabs" for that. */ + +static void +maintenance_check_symtabs (char *ignore, int from_tty) +{ + struct program_space *pspace; + struct objfile *objfile; + + ALL_PSPACES (pspace) + ALL_PSPACE_OBJFILES (pspace, objfile) + { + struct compunit_symtab *cust; + + /* We don't want to print anything for this objfile until we + actually find something worth printing. */ + int printed_objfile_start = 0; + + ALL_OBJFILE_COMPUNITS (objfile, cust) { + int found_something = 0; + struct symtab *symtab = compunit_primary_filetab (cust); + QUIT; - if (! regexp - || re_exec (symtab_to_filename_for_display (symtab))) + if (COMPUNIT_BLOCKVECTOR (cust) == NULL) + found_something = 1; + /* Add more checks here. */ + + if (found_something) { if (! printed_objfile_start) { - printf_filtered ("{ objfile %s ", objfile->name); + printf_filtered ("{ objfile %s ", objfile_name (objfile)); wrap_here (" "); - printf_filtered ("((struct objfile *) %s)\n", + printf_filtered ("((struct objfile *) %s)\n", host_address_to_string (objfile)); printed_objfile_start = 1; } - - printf_filtered (" { symtab %s ", + printf_filtered (" { symtab %s\n", symtab_to_filename_for_display (symtab)); - wrap_here (" "); - printf_filtered ("((struct symtab *) %s)\n", - host_address_to_string (symtab)); - printf_filtered (" dirname %s\n", - symtab->dirname ? symtab->dirname : "(null)"); - printf_filtered (" fullname %s\n", - symtab->fullname ? symtab->fullname : "(null)"); - printf_filtered (" " - "blockvector ((struct blockvector *) %s)%s\n", - host_address_to_string (symtab->blockvector), - symtab->primary ? " (primary)" : ""); - printf_filtered (" " - "linetable ((struct linetable *) %s)\n", - host_address_to_string (symtab->linetable)); - printf_filtered (" debugformat %s\n", - symtab->debugformat); - printf_filtered (" }\n"); + if (COMPUNIT_BLOCKVECTOR (cust) == NULL) + printf_filtered (" NULL blockvector\n"); + printf_filtered (" }\n"); } } @@ -771,6 +862,80 @@ maintenance_info_symtabs (char *regexp, int from_tty) printf_filtered ("}\n"); } } + +/* Helper function for maintenance_expand_symtabs. + This is the name_matcher function for expand_symtabs_matching. */ + +static int +maintenance_expand_name_matcher (const char *symname, void *data) +{ + /* Since we're not searching on symbols, just return TRUE. */ + return 1; +} + +/* Helper function for maintenance_expand_symtabs. + This is the file_matcher function for expand_symtabs_matching. */ + +static int +maintenance_expand_file_matcher (const char *filename, void *data, + int basenames) +{ + const char *regexp = (const char *) data; + + QUIT; + + /* KISS: Only apply the regexp to the complete file name. */ + if (basenames) + return 0; + + if (regexp == NULL || re_exec (filename)) + return 1; + + return 0; +} + +/* Expand all symbol tables whose name matches an optional regexp. */ + +static void +maintenance_expand_symtabs (char *args, int from_tty) +{ + struct program_space *pspace; + struct objfile *objfile; + struct cleanup *cleanups; + char **argv; + char *regexp = NULL; + + /* We use buildargv here so that we handle spaces in the regexp + in a way that allows adding more arguments later. */ + argv = gdb_buildargv (args); + cleanups = make_cleanup_freeargv (argv); + + if (argv != NULL) + { + if (argv[0] != NULL) + { + regexp = argv[0]; + if (argv[1] != NULL) + error (_("Extra arguments after regexp.")); + } + } + + if (regexp) + re_comp (regexp); + + ALL_PSPACES (pspace) + ALL_PSPACE_OBJFILES (pspace, objfile) + { + if (objfile->sf) + { + objfile->sf->qf->expand_symtabs_matching + (objfile, maintenance_expand_file_matcher, + maintenance_expand_name_matcher, NULL, ALL_DOMAIN, regexp); + } + } + + do_cleanups (cleanups); +} /* Return the nexting depth of a block within other blocks in its symtab. */ @@ -788,6 +953,90 @@ block_depth (struct block *block) } +/* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a + single line table. */ + +static int +maintenance_print_one_line_table (struct symtab *symtab, void *data) +{ + struct linetable *linetable; + struct objfile *objfile; + + objfile = symtab->compunit_symtab->objfile; + printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"), + objfile_name (objfile), + host_address_to_string (objfile)); + printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"), + host_address_to_string (symtab->compunit_symtab)); + printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"), + symtab_to_fullname (symtab), + host_address_to_string (symtab)); + linetable = SYMTAB_LINETABLE (symtab); + printf_filtered (_("linetable: ((struct linetable *) %s):\n"), + host_address_to_string (linetable)); + + if (linetable == NULL) + printf_filtered (_("No line table.\n")); + else if (linetable->nitems <= 0) + printf_filtered (_("Line table has no lines.\n")); + else + { + int i; + + /* Leave space for 6 digits of index and line number. After that the + tables will just not format as well. */ + printf_filtered (_("%-6s %6s %s\n"), + _("INDEX"), _("LINE"), _("ADDRESS")); + + for (i = 0; i < linetable->nitems; ++i) + { + struct linetable_entry *item; + struct cleanup *row_cleanup; + + item = &linetable->item [i]; + printf_filtered (_("%-6d %6d %s\n"), i, item->line, + core_addr_to_string (item->pc)); + } + } + + return 0; +} + +/* Implement the 'maint info line-table' command. */ + +static void +maintenance_info_line_tables (char *regexp, int from_tty) +{ + struct program_space *pspace; + struct objfile *objfile; + + dont_repeat (); + + if (regexp != NULL) + re_comp (regexp); + + ALL_PSPACES (pspace) + ALL_PSPACE_OBJFILES (pspace, objfile) + { + struct compunit_symtab *cust; + struct symtab *symtab; + + ALL_OBJFILE_COMPUNITS (objfile, cust) + { + ALL_COMPUNIT_FILETABS (cust, symtab) + { + QUIT; + + if (regexp == NULL + || re_exec (symtab_to_filename_for_display (symtab))) + maintenance_print_one_line_table (symtab, NULL); + } + } + } +} + + + /* Do early runtime initializations. */ void @@ -810,13 +1059,30 @@ If a SOURCE file is specified, dump only that file's minimal symbols."), &maintenanceprintlist); add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles, - _("Print dump of current object file definitions."), + _("Print dump of current object file definitions.\n\ +With an argument REGEXP, list the object files with matching names."), &maintenanceprintlist); add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\ List the full symbol tables for all object files.\n\ This does not include information about individual symbols, blocks, or\n\ linetables --- just the symbol table structures themselves.\n\ -With an argument REGEXP, list the symbol tables whose names that match that."), +With an argument REGEXP, list the symbol tables with matching names."), &maintenanceinfolist); + + add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\ +List the contents of all line tables, from all symbol tables.\n\ +With an argument REGEXP, list just the line tables for the symbol\n\ +tables with matching names."), + &maintenanceinfolist); + + add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs, + _("\ +Check consistency of currently expanded symtabs."), + &maintenancelist); + + add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs, + _("Expand symbol tables.\n\ +With an argument REGEXP, only expand the symbol tables with matching names."), + &maintenancelist); }