X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsymmisc.c;h=811183cf0816f273bacdbd26f1c277643abce4e8;hb=545e07dffdaf1b79497a866772caf0dd6e0a243f;hp=c49ab1f7e503d1e8abe15674f08635c00f6731b8;hpb=82585c726542fe34a6e3108ce281759f4de08d57;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index c49ab1f7e5..811183cf08 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -1,8 +1,6 @@
 /* Do various things to symbol tables (other than lookup), for GDB.
 
-   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1986-2017 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -23,25 +21,24 @@
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "bfd.h"
+#include "filenames.h"
 #include "symfile.h"
 #include "objfiles.h"
 #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 <sys/stat.h>
 #include "dictionary.h"
-
-#include "gdb_string.h"
+#include "typeprint.h"
+#include "gdbcmd.h"
+#include "source.h"
 #include "readline/readline.h"
 
-#ifndef DEV_TTY
-#define DEV_TTY "/dev/tty"
-#endif
+#include "psymtab.h"
 
 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
    when calling functions that take FILE *'s from the debugger.
@@ -55,147 +52,62 @@ FILE *std_err;
 
 /* Prototypes for local functions */
 
-static void dump_symtab (struct objfile *, struct symtab *,
-			 struct ui_file *);
-
-static void dump_psymtab (struct objfile *, struct partial_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 *);
 
-static void print_partial_symbols (struct partial_symbol **, int,
-				   char *, struct ui_file *);
-
-static void free_symtab_block (struct objfile *, struct block *);
-
 void _initialize_symmisc (void);
 
 struct print_symbol_args
   {
+    struct gdbarch *gdbarch;
     struct symbol *symbol;
     int depth;
     struct ui_file *outfile;
   };
 
 static int print_symbol (void *);
-
-static void free_symtab_block (struct objfile *, struct block *);
 
 
-/* Free a struct block <- B and all the symbols defined in that block.  */
-
-/* FIXME: carlton/2003-04-28: I don't believe this is currently ever
-   used.  */
-
-static void
-free_symtab_block (struct objfile *objfile, struct block *b)
-{
-  struct dict_iterator iter;
-  struct symbol *sym;
-
-  ALL_BLOCK_SYMBOLS (b, iter, sym)
-    {
-      xfree (DEPRECATED_SYMBOL_NAME (sym));
-      xfree (sym);
-    }
-
-  dict_free (BLOCK_DICT (b));
-  xfree (b);
-}
-
-/* Free all the storage associated with the struct symtab <- S.
-   Note that some symtabs have contents malloc'ed structure by structure,
-   while some have contents that all live inside one big block of memory,
-   and some share the contents of another symbol table and so you should
-   not free the contents on their behalf (except sometimes the linetable,
-   which maybe per symtab even when the rest is not).
-   It is s->free_code that says which alternative to use.  */
-
-void
-free_symtab (struct symtab *s)
-{
-  int i, n;
-  struct blockvector *bv;
-
-  switch (s->free_code)
-    {
-    case free_nothing:
-      /* All the contents are part of a big block of memory (an obstack),
-         and some other symtab is in charge of freeing that block.
-         Therefore, do nothing.  */
-      break;
-
-    case free_contents:
-      /* Here all the contents were malloc'ed structure by structure
-         and must be freed that way.  */
-      /* First free the blocks (and their symbols.  */
-      bv = BLOCKVECTOR (s);
-      n = BLOCKVECTOR_NBLOCKS (bv);
-      for (i = 0; i < n; i++)
-	free_symtab_block (s->objfile, BLOCKVECTOR_BLOCK (bv, i));
-      /* Free the blockvector itself.  */
-      xfree (bv);
-      /* Also free the linetable.  */
-
-    case free_linetable:
-      /* Everything will be freed either by our `free_func'
-         or by some other symtab, except for our linetable.
-         Free that now.  */
-      if (LINETABLE (s))
-	xfree (LINETABLE (s));
-      break;
-    }
-
-  /* If there is a single block of memory to free, free it.  */
-  if (s->free_func != NULL)
-    s->free_func (s);
-
-  /* Free source-related stuff */
-  if (s->line_charpos != NULL)
-    xfree (s->line_charpos);
-  if (s->fullname != NULL)
-    xfree (s->fullname);
-  if (s->debugformat != NULL)
-    xfree (s->debugformat);
-  xfree (s);
-}
-
 void
 print_symbol_bcache_statistics (void)
 {
+  struct program_space *pspace;
   struct objfile *objfile;
 
-  immediate_quit++;
-  ALL_OBJFILES (objfile)
+  ALL_PSPACES (pspace)
+    ALL_PSPACE_OBJFILES (pspace, objfile)
   {
-    printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
-    print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
+    QUIT;
+    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,
+			     "preprocessor macro cache");
+    print_bcache_statistics (objfile->per_bfd->filename_cache,
+			     "file name cache");
   }
-  immediate_quit--;
 }
 
 void
 print_objfile_statistics (void)
 {
+  struct program_space *pspace;
   struct objfile *objfile;
+  struct compunit_symtab *cu;
   struct symtab *s;
-  struct partial_symtab *ps;
   int i, linetables, blockvectors;
 
-  immediate_quit++;
-  ALL_OBJFILES (objfile)
+  ALL_PSPACES (pspace)
+    ALL_PSPACE_OBJFILES (pspace, objfile)
   {
-    printf_filtered (_("Statistics for '%s':\n"), objfile->name);
+    QUIT;
+    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));
@@ -205,86 +117,68 @@ print_objfile_statistics (void)
     if (OBJSTAT (objfile, n_types) > 0)
       printf_filtered (_("  Number of \"types\" defined: %d\n"),
 		       OBJSTAT (objfile, n_types));
-    i = 0;
-    ALL_OBJFILE_PSYMTABS (objfile, ps)
-      {
-        if (ps->readin == 0)
-          i++;
-      }
-    printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
+    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"),
+      printf_filtered (_("  Space used by 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 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 (objfile->psymbol_cache));
+		     bcache_memory_used (psymbol_bcache_get_bcache
+		                          (objfile->psymbol_cache)));
     printf_filtered (_("  Total memory used for macro cache: %d\n"),
-		     bcache_memory_used (objfile->macro_cache));
+		     bcache_memory_used (objfile->per_bfd->macro_cache));
+    printf_filtered (_("  Total memory used for file name cache: %d\n"),
+		     bcache_memory_used (objfile->per_bfd->filename_cache));
   }
-  immediate_quit--;
 }
 
 static void
 dump_objfile (struct objfile *objfile)
 {
+  struct compunit_symtab *cust;
   struct symtab *symtab;
-  struct partial_symtab *psymtab;
 
-  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->psymtabs)
-    {
-      printf_filtered ("Psymtabs:\n");
-      for (psymtab = objfile->psymtabs;
-	   psymtab != NULL;
-	   psymtab = psymtab->next)
-	{
-	  printf_filtered ("%s at ",
-			   psymtab->filename);
-	  gdb_print_host_address (psymtab, gdb_stdout);
-	  printf_filtered (", ");
-	  if (psymtab->objfile != objfile)
-	    {
-	      printf_filtered ("NOT ON CHAIN!  ");
-	    }
-	  wrap_here ("  ");
-	}
-      printf_filtered ("\n\n");
-    }
+  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->filename);
+	  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!  ");
 	    }
@@ -299,20 +193,23 @@ dump_objfile (struct objfile *objfile)
 static void
 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct minimal_symbol *msymbol;
   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;
     }
-  for (index = 0, msymbol = objfile->msymbols;
-       DEPRECATED_SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
+  index = 0;
+  ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
     {
-      switch (msymbol->type)
+      struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
+
+      switch (MSYMBOL_TYPE (msymbol))
 	{
 	case mst_unknown:
 	  ms_type = 'u';
@@ -320,6 +217,9 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 	case mst_text:
 	  ms_type = 'T';
 	  break;
+	case mst_text_gnu_ifunc:
+	  ms_type = 'i';
+	  break;
 	case mst_solib_trampoline:
 	  ms_type = 'S';
 	  break;
@@ -346,121 +246,65 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 	  break;
 	}
       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
-      deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1, outfile);
-      fprintf_filtered (outfile, " %s", DEPRECATED_SYMBOL_NAME (msymbol));
-      if (SYMBOL_BFD_SECTION (msymbol))
-	fprintf_filtered (outfile, " section %s",
-			  bfd_section_name (objfile->obfd,
-					    SYMBOL_BFD_SECTION (msymbol)));
-      if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
+      fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
+								msymbol)),
+		      outfile);
+      fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
+      if (section)
+	{
+	  if (section->the_bfd_section != NULL)
+	    fprintf_filtered (outfile, " section %s",
+			      bfd_section_name (objfile->obfd,
+						section->the_bfd_section));
+	  else
+	    fprintf_filtered (outfile, " spurious section %ld",
+			      (long) (section - objfile->sections));
+	}
+      if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 	{
-	  fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
+	  fprintf_filtered (outfile, "  %s", MSYMBOL_DEMANGLED_NAME (msymbol));
 	}
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
       if (msymbol->filename)
 	fprintf_filtered (outfile, "  %s", msymbol->filename);
-#endif
       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_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
-	      struct ui_file *outfile)
-{
-  int i;
-
-  fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
-		    psymtab->filename);
-  fprintf_filtered (outfile, "(object ");
-  gdb_print_host_address (psymtab, outfile);
-  fprintf_filtered (outfile, ")\n\n");
-  fprintf_unfiltered (outfile, "  Read from object file %s (",
-		      objfile->name);
-  gdb_print_host_address (objfile, outfile);
-  fprintf_unfiltered (outfile, ")\n");
-
-  if (psymtab->readin)
-    {
-      fprintf_filtered (outfile,
-			"  Full symtab was read (at ");
-      gdb_print_host_address (psymtab->symtab, outfile);
-      fprintf_filtered (outfile, " by function at ");
-      gdb_print_host_address (psymtab->read_symtab, outfile);
-      fprintf_filtered (outfile, ")\n");
-    }
-
-  fprintf_filtered (outfile, "  Relocate symbols by ");
-  for (i = 0; i < psymtab->objfile->num_sections; ++i)
-    {
-      if (i != 0)
-	fprintf_filtered (outfile, ", ");
-      wrap_here ("    ");
-      deprecated_print_address_numeric (ANOFFSET (psymtab->section_offsets, i),
-			     1,
-			     outfile);
-    }
-  fprintf_filtered (outfile, "\n");
-
-  fprintf_filtered (outfile, "  Symbols cover text addresses ");
-  deprecated_print_address_numeric (psymtab->textlow, 1, outfile);
-  fprintf_filtered (outfile, "-");
-  deprecated_print_address_numeric (psymtab->texthigh, 1, outfile);
-  fprintf_filtered (outfile, "\n");
-  fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
-		    psymtab->number_of_dependencies);
-  for (i = 0; i < psymtab->number_of_dependencies; i++)
-    {
-      fprintf_filtered (outfile, "    %d ", i);
-      gdb_print_host_address (psymtab->dependencies[i], outfile);
-      fprintf_filtered (outfile, " %s\n",
-			psymtab->dependencies[i]->filename);
-    }
-  if (psymtab->n_global_syms > 0)
-    {
-      print_partial_symbols (objfile->global_psymbols.list
-			     + psymtab->globals_offset,
-			     psymtab->n_global_syms, "Global", outfile);
-    }
-  if (psymtab->n_static_syms > 0)
-    {
-      print_partial_symbols (objfile->static_psymbols.list
-			     + psymtab->statics_offset,
-			     psymtab->n_static_syms, "Static", outfile);
-    }
-  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, blen;
+  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->filename);
-  if (symtab->dirname)
+  fprintf_filtered (outfile, "\nSymtab for file %s\n",
+		    symtab_to_filename_for_display (symtab));
+  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));
+  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");
@@ -468,16 +312,16 @@ dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
       for (i = 0; i < len; i++)
 	{
 	  fprintf_filtered (outfile, " line %d at ", l->item[i].line);
-	  deprecated_print_address_numeric (l->item[i].pc, 1, outfile);
+	  fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
 	  fprintf_filtered (outfile, "\n");
 	}
     }
-  /* Now print the block info, but only for primary symtabs since we will
-     print lots of duplicate info otherwise. */
-  if (symtab->primary)
+  /* Now print the block info, but only for compunit symtabs since we will
+     print lots of duplicate info otherwise.  */
+  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++)
 	{
@@ -496,12 +340,13 @@ dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 	     wants it.  */
 	  fprintf_filtered (outfile, ", %d syms/buckets in ",
 			    dict_size (BLOCK_DICT (b)));
-	  deprecated_print_address_numeric (BLOCK_START (b), 1, outfile);
+	  fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 	  fprintf_filtered (outfile, "..");
-	  deprecated_print_address_numeric (BLOCK_END (b), 1, outfile);
+	  fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 	  if (BLOCK_FUNCTION (b))
 	    {
-	      fprintf_filtered (outfile, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b)));
+	      fprintf_filtered (outfile, ", function %s",
+				SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
 	      if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 		{
 		  fprintf_filtered (outfile, ", %s",
@@ -510,88 +355,171 @@ dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 	    }
 	  fprintf_filtered (outfile, "\n");
 	  /* Now print each symbol in this block (in no particular order, if
-	     we're using a hashtable).  */
-	  ALL_BLOCK_SYMBOLS (b, iter, sym)
+	     we're using a hashtable).  Note that we only want this
+	     block, not any blocks from included symtabs.  */
+	  ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
 	    {
 	      struct print_symbol_args s;
+
+	      s.gdbarch = gdbarch;
 	      s.symbol = sym;
 	      s.depth = depth + 1;
 	      s.outfile = outfile;
 	      catch_errors (print_symbol, &s, "Error printing symbol:\n",
-			    RETURN_MASK_ALL);
+			    RETURN_MASK_ERROR);
 	    }
 	}
       fprintf_filtered (outfile, "\n");
     }
   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)
 {
-  enum language saved_lang;
-
   /* Set the current language to the language of the symtab we're dumping
      because certain routines used during dump_symtab() use the current
-     language to print an image of the symbol.  We'll restore it later.  */
-  saved_lang = set_language (symtab->language);
+     language to print an image of the symbol.  We'll restore it later.
+     But use only real languages, not placeholders.  */
+  if (symtab->language != language_unknown
+      && symtab->language != language_auto)
+    {
+      enum language saved_lang;
+
+      saved_lang = set_language (symtab->language);
 
-  dump_symtab_1 (objfile, symtab, outfile);
+      dump_symtab_1 (symtab, outfile);
 
-  set_language (saved_lang);
+      set_language (saved_lang);
+    }
+  else
+    dump_symtab_1 (symtab, outfile);
 }
 
-void
+static void
 maintenance_print_symbols (char *args, int from_tty)
 {
   char **argv;
-  struct ui_file *outfile;
+  struct ui_file *outfile = gdb_stdout;
   struct cleanup *cleanups;
-  char *symname = NULL;
-  char *filename = DEV_TTY;
-  struct objfile *objfile;
-  struct symtab *s;
+  char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
+  int i, outfile_idx;
 
   dont_repeat ();
 
-  if (args == NULL)
+  argv = gdb_buildargv (args);
+  cleanups = make_cleanup_freeargv (argv);
+
+  for (i = 0; argv[i] != NULL; ++i)
     {
-      error (_("\
-Arguments missing: an output file name and an optional symbol file name"));
+      if (strcmp (argv[i], "-pc") == 0)
+	{
+	  if (argv[i + 1] == NULL)
+	    error (_("Missing pc value"));
+	  address_arg = argv[++i];
+	}
+      else if (strcmp (argv[i], "-source") == 0)
+	{
+	  if (argv[i + 1] == NULL)
+	    error (_("Missing source file"));
+	  source_arg = argv[++i];
+	}
+      else if (strcmp (argv[i], "-objfile") == 0)
+	{
+	  if (argv[i + 1] == NULL)
+	    error (_("Missing objfile name"));
+	  objfile_arg = argv[++i];
+	}
+      else if (strcmp (argv[i], "--") == 0)
+	{
+	  /* End of options.  */
+	  ++i;
+	  break;
+	}
+      else if (argv[i][0] == '-')
+	{
+	  /* Future proofing: Don't allow OUTFILE to begin with "-".  */
+	  error (_("Unknown option: %s"), argv[i]);
+	}
+      else
+	break;
     }
-  else if ((argv = buildargv (args)) == NULL)
+  outfile_idx = i;
+
+  if (address_arg != NULL && source_arg != NULL)
+    error (_("Must specify at most one of -pc and -source"));
+
+  if (argv[outfile_idx] != NULL)
     {
-      nomem (0);
+      char *outfile_name;
+
+      if (argv[outfile_idx + 1] != NULL)
+	error (_("Junk at end of command"));
+      outfile_name = tilde_expand (argv[outfile_idx]);
+      make_cleanup (xfree, outfile_name);
+      outfile = gdb_fopen (outfile_name, FOPEN_WT);
+      if (outfile == NULL)
+	perror_with_name (outfile_name);
+      make_cleanup_ui_file_delete (outfile);
     }
-  cleanups = make_cleanup_freeargv (argv);
 
-  if (argv[0] != NULL)
+  if (address_arg != NULL)
     {
-      filename = argv[0];
-      /* If a second arg is supplied, it is a source file name to match on */
-      if (argv[1] != NULL)
-	{
-	  symname = argv[1];
-	}
+      CORE_ADDR pc = parse_and_eval_address (address_arg);
+      struct symtab *s = find_pc_line_symtab (pc);
+
+      if (s == NULL)
+	error (_("No symtab for address: %s"), address_arg);
+      dump_symtab (s, outfile);
     }
+  else
+    {
+      struct objfile *objfile;
+      struct compunit_symtab *cu;
+      struct symtab *s;
+      int found = 0;
 
-  filename = tilde_expand (filename);
-  make_cleanup (xfree, filename);
+      ALL_OBJFILES (objfile)
+	{
+	  int print_for_objfile = 1;
 
-  outfile = gdb_fopen (filename, FOPEN_WT);
-  if (outfile == 0)
-    perror_with_name (filename);
-  make_cleanup_ui_file_delete (outfile);
+	  if (objfile_arg != NULL)
+	    print_for_objfile
+	      = compare_filenames_for_search (objfile_name (objfile),
+					      objfile_arg);
+	  if (!print_for_objfile)
+	    continue;
+
+	  ALL_OBJFILE_FILETABS (objfile, cu, s)
+	    {
+	      int print_for_source = 0;
+
+	      QUIT;
+	      if (source_arg != NULL)
+		{
+		  print_for_source
+		    = compare_filenames_for_search
+		        (symtab_to_filename_for_display (s), source_arg);
+		  found = 1;
+		}
+	      if (source_arg == NULL
+		  || print_for_source)
+		dump_symtab (s, outfile);
+	    }
+	}
+
+      if (source_arg != NULL && !found)
+	error (_("No symtab for source file: %s"), source_arg);
+    }
 
-  immediate_quit++;
-  ALL_SYMTABS (objfile, s)
-    if (symname == NULL || strcmp (symname, s->filename) == 0)
-    dump_symtab (objfile, s, outfile);
-  immediate_quit--;
   do_cleanups (cleanups);
 }
 
@@ -603,19 +531,27 @@ Arguments missing: an output file name and an optional symbol file name"));
 static int
 print_symbol (void *args)
 {
+  struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
   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;
+
+  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)
     {
       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
-      deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
-      if (SYMBOL_BFD_SECTION (symbol))
+      fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+		      outfile);
+      if (section)
 	fprintf_filtered (outfile, " section %s\n",
-		       bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
-					 SYMBOL_BFD_SECTION (symbol)));
+			  bfd_section_name (section->the_bfd_section->owner,
+					    section->the_bfd_section));
       else
 	fprintf_filtered (outfile, "\n");
       return 1;
@@ -624,7 +560,8 @@ print_symbol (void *args)
     {
       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 	{
-	  LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
+	  LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
+			 &type_print_raw_options);
 	}
       else
 	{
@@ -633,8 +570,9 @@ print_symbol (void *args)
 			  ? "enum"
 		     : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 			? "struct" : "union")),
-			    DEPRECATED_SYMBOL_NAME (symbol));
-	  LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
+			    SYMBOL_LINKAGE_NAME (symbol));
+	  LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
+			 &type_print_raw_options);
 	}
       fprintf_filtered (outfile, ";\n");
     }
@@ -648,7 +586,8 @@ print_symbol (void *args)
 	  LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 			 outfile,
 			 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
-			 depth);
+			 depth,
+			 &type_print_raw_options);
 	  fprintf_filtered (outfile, "; ");
 	}
       else
@@ -657,15 +596,16 @@ print_symbol (void *args)
       switch (SYMBOL_CLASS (symbol))
 	{
 	case LOC_CONST:
-	  fprintf_filtered (outfile, "const %ld (0x%lx)",
-			    SYMBOL_VALUE (symbol),
-			    SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "const %s (%s)",
+			    plongest (SYMBOL_VALUE (symbol)),
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_CONST_BYTES:
 	  {
 	    unsigned i;
 	    struct type *type = check_typedef (SYMBOL_TYPE (symbol));
+
 	    fprintf_filtered (outfile, "const %u hex bytes:",
 			      TYPE_LENGTH (type));
 	    for (i = 0; i < TYPE_LENGTH (type); i++)
@@ -676,59 +616,41 @@ print_symbol (void *args)
 
 	case LOC_STATIC:
 	  fprintf_filtered (outfile, "static at ");
-	  deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
-	  if (SYMBOL_BFD_SECTION (symbol))
+	  fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+			  outfile);
+	  if (section)
 	    fprintf_filtered (outfile, " section %s",
-			      bfd_section_name
-			      (SYMBOL_BFD_SECTION (symbol)->owner,
-			       SYMBOL_BFD_SECTION (symbol)));
-	  break;
-
-	case LOC_INDIRECT:
-	  fprintf_filtered (outfile, "extern global at *(");
-	  deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
-	  fprintf_filtered (outfile, "),");
+			      bfd_section_name (section->the_bfd_section->owner,
+						section->the_bfd_section));
 	  break;
 
 	case LOC_REGISTER:
-	  fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
+	  if (SYMBOL_IS_ARGUMENT (symbol))
+	    fprintf_filtered (outfile, "parameter register %s",
+			      plongest (SYMBOL_VALUE (symbol)));
+	  else
+	    fprintf_filtered (outfile, "register %s",
+			      plongest (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_ARG:
-	  fprintf_filtered (outfile, "arg at offset 0x%lx",
-			    SYMBOL_VALUE (symbol));
-	  break;
-
-	case LOC_LOCAL_ARG:
-	  fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
-			    SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "arg at offset %s",
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_REF_ARG:
-	  fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
-	  break;
-
-	case LOC_REGPARM:
-	  fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "reference arg at %s",
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_REGPARM_ADDR:
-	  fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "address parameter register %s",
+			    plongest (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_LOCAL:
-	  fprintf_filtered (outfile, "local at offset 0x%lx",
-			    SYMBOL_VALUE (symbol));
-	  break;
-
-	case LOC_BASEREG:
-	  fprintf_filtered (outfile, "local at 0x%lx from register %d",
-			    SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
-	  break;
-
-	case LOC_BASEREG_ARG:
-	  fprintf_filtered (outfile, "arg at 0x%lx from register %d",
-			    SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
+	  fprintf_filtered (outfile, "local at offset %s",
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_TYPEDEF:
@@ -736,34 +658,32 @@ print_symbol (void *args)
 
 	case LOC_LABEL:
 	  fprintf_filtered (outfile, "label at ");
-	  deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
-	  if (SYMBOL_BFD_SECTION (symbol))
+	  fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+			  outfile);
+	  if (section)
 	    fprintf_filtered (outfile, " section %s",
-			      bfd_section_name
-			      (SYMBOL_BFD_SECTION (symbol)->owner,
-			       SYMBOL_BFD_SECTION (symbol)));
+			      bfd_section_name (section->the_bfd_section->owner,
+						section->the_bfd_section));
 	  break;
 
 	case LOC_BLOCK:
 	  fprintf_filtered (outfile, "block object ");
 	  gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 	  fprintf_filtered (outfile, ", ");
-	  deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
-				 1,
-				 outfile);
+	  fputs_filtered (paddress (gdbarch,
+				    BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
+			  outfile);
 	  fprintf_filtered (outfile, "..");
-	  deprecated_print_address_numeric (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol)),
-				 1,
-				 outfile);
-	  if (SYMBOL_BFD_SECTION (symbol))
+	  fputs_filtered (paddress (gdbarch,
+				    BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
+			  outfile);
+	  if (section)
 	    fprintf_filtered (outfile, " section %s",
-			      bfd_section_name
-			      (SYMBOL_BFD_SECTION (symbol)->owner,
-			       SYMBOL_BFD_SECTION (symbol)));
+			      bfd_section_name (section->the_bfd_section->owner,
+						section->the_bfd_section));
 	  break;
 
 	case LOC_COMPUTED:
-	case LOC_COMPUTED_ARG:
 	  fprintf_filtered (outfile, "computed at runtime");
 	  break;
 
@@ -785,443 +705,308 @@ print_symbol (void *args)
   return 1;
 }
 
-void
-maintenance_print_psymbols (char *args, int from_tty)
+static void
+maintenance_print_msymbols (char *args, int from_tty)
 {
   char **argv;
-  struct ui_file *outfile;
+  struct ui_file *outfile = gdb_stdout;
   struct cleanup *cleanups;
-  char *symname = NULL;
-  char *filename = DEV_TTY;
+  char *objfile_arg = NULL;
   struct objfile *objfile;
-  struct partial_symtab *ps;
+  int i, outfile_idx;
 
   dont_repeat ();
 
-  if (args == NULL)
-    {
-      error (_("print-psymbols takes an output file name and optional symbol file name"));
-    }
-  else if ((argv = buildargv (args)) == NULL)
-    {
-      nomem (0);
-    }
+  argv = gdb_buildargv (args);
   cleanups = make_cleanup_freeargv (argv);
 
-  if (argv[0] != NULL)
+  for (i = 0; argv[i] != NULL; ++i)
     {
-      filename = argv[0];
-      /* If a second arg is supplied, it is a source file name to match on */
-      if (argv[1] != NULL)
+      if (strcmp (argv[i], "-objfile") == 0)
 	{
-	  symname = argv[1];
+	  if (argv[i + 1] == NULL)
+	    error (_("Missing objfile name"));
+	  objfile_arg = argv[++i];
 	}
-    }
-
-  filename = tilde_expand (filename);
-  make_cleanup (xfree, filename);
-
-  outfile = gdb_fopen (filename, FOPEN_WT);
-  if (outfile == 0)
-    perror_with_name (filename);
-  make_cleanup_ui_file_delete (outfile);
-
-  immediate_quit++;
-  ALL_PSYMTABS (objfile, ps)
-    if (symname == NULL || strcmp (symname, ps->filename) == 0)
-    dump_psymtab (objfile, ps, outfile);
-  immediate_quit--;
-  do_cleanups (cleanups);
-}
-
-static void
-print_partial_symbols (struct partial_symbol **p, int count, char *what,
-		       struct ui_file *outfile)
-{
-  fprintf_filtered (outfile, "  %s partial symbols:\n", what);
-  while (count-- > 0)
-    {
-      fprintf_filtered (outfile, "    `%s'", DEPRECATED_SYMBOL_NAME (*p));
-      if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
+      else if (strcmp (argv[i], "--") == 0)
 	{
-	  fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (*p));
-	}
-      fputs_filtered (", ", outfile);
-      switch (SYMBOL_DOMAIN (*p))
-	{
-	case UNDEF_DOMAIN:
-	  fputs_filtered ("undefined domain, ", outfile);
-	  break;
-	case VAR_DOMAIN:
-	  /* This is the usual thing -- don't print it */
-	  break;
-	case STRUCT_DOMAIN:
-	  fputs_filtered ("struct domain, ", outfile);
-	  break;
-	case LABEL_DOMAIN:
-	  fputs_filtered ("label domain, ", outfile);
-	  break;
-	default:
-	  fputs_filtered ("<invalid domain>, ", outfile);
+	  /* End of options.  */
+	  ++i;
 	  break;
 	}
-      switch (SYMBOL_CLASS (*p))
+      else if (argv[i][0] == '-')
 	{
-	case LOC_UNDEF:
-	  fputs_filtered ("undefined", outfile);
-	  break;
-	case LOC_CONST:
-	  fputs_filtered ("constant int", outfile);
-	  break;
-	case LOC_STATIC:
-	  fputs_filtered ("static", outfile);
-	  break;
-	case LOC_INDIRECT:
-	  fputs_filtered ("extern global", outfile);
-	  break;
-	case LOC_REGISTER:
-	  fputs_filtered ("register", outfile);
-	  break;
-	case LOC_ARG:
-	  fputs_filtered ("pass by value", outfile);
-	  break;
-	case LOC_REF_ARG:
-	  fputs_filtered ("pass by reference", outfile);
-	  break;
-	case LOC_REGPARM:
-	  fputs_filtered ("register parameter", outfile);
-	  break;
-	case LOC_REGPARM_ADDR:
-	  fputs_filtered ("register address parameter", outfile);
-	  break;
-	case LOC_LOCAL:
-	  fputs_filtered ("stack parameter", outfile);
-	  break;
-	case LOC_TYPEDEF:
-	  fputs_filtered ("type", outfile);
-	  break;
-	case LOC_LABEL:
-	  fputs_filtered ("label", outfile);
-	  break;
-	case LOC_BLOCK:
-	  fputs_filtered ("function", outfile);
-	  break;
-	case LOC_CONST_BYTES:
-	  fputs_filtered ("constant bytes", outfile);
-	  break;
-	case LOC_LOCAL_ARG:
-	  fputs_filtered ("shuffled arg", outfile);
-	  break;
-	case LOC_UNRESOLVED:
-	  fputs_filtered ("unresolved", outfile);
-	  break;
-	case LOC_OPTIMIZED_OUT:
-	  fputs_filtered ("optimized out", outfile);
-	  break;
-	case LOC_COMPUTED:
-	case LOC_COMPUTED_ARG:
-	  fputs_filtered ("computed at runtime", outfile);
-	  break;
-	default:
-	  fputs_filtered ("<invalid location>", outfile);
-	  break;
+	  /* Future proofing: Don't allow OUTFILE to begin with "-".  */
+	  error (_("Unknown option: %s"), argv[i]);
 	}
-      fputs_filtered (", ", outfile);
-      deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (*p), 1, outfile);
-      fprintf_filtered (outfile, "\n");
-      p++;
-    }
-}
-
-void
-maintenance_print_msymbols (char *args, int from_tty)
-{
-  char **argv;
-  struct ui_file *outfile;
-  struct cleanup *cleanups;
-  char *filename = DEV_TTY;
-  char *symname = NULL;
-  struct objfile *objfile;
-
-  struct stat sym_st, obj_st;
-
-  dont_repeat ();
-
-  if (args == NULL)
-    {
-      error (_("print-msymbols takes an output file name and optional symbol file name"));
-    }
-  else if ((argv = buildargv (args)) == NULL)
-    {
-      nomem (0);
+      else
+	break;
     }
-  cleanups = make_cleanup_freeargv (argv);
+  outfile_idx = i;
 
-  if (argv[0] != NULL)
+  if (argv[outfile_idx] != NULL)
     {
-      filename = argv[0];
-      /* If a second arg is supplied, it is a source file name to match on */
-      if (argv[1] != NULL)
-	{
-	  symname = xfullpath (argv[1]);
-	  make_cleanup (xfree, symname);
-	  if (symname && stat (symname, &sym_st))
-	    perror_with_name (symname);
-	}
+      char *outfile_name;
+
+      if (argv[outfile_idx + 1] != NULL)
+	error (_("Junk at end of command"));
+      outfile_name = tilde_expand (argv[outfile_idx]);
+      make_cleanup (xfree, outfile_name);
+      outfile = gdb_fopen (outfile_name, FOPEN_WT);
+      if (outfile == NULL)
+	perror_with_name (outfile_name);
+      make_cleanup_ui_file_delete (outfile);
     }
 
-  filename = tilde_expand (filename);
-  make_cleanup (xfree, filename);
-
-  outfile = gdb_fopen (filename, FOPEN_WT);
-  if (outfile == 0)
-    perror_with_name (filename);
-  make_cleanup_ui_file_delete (outfile);
-
-  immediate_quit++;
   ALL_OBJFILES (objfile)
-    if (symname == NULL
-	|| (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
+  {
+    QUIT;
+    if (objfile_arg == NULL
+	|| compare_filenames_for_search (objfile_name (objfile), objfile_arg))
       dump_msymbols (objfile, outfile);
-  immediate_quit--;
-  fprintf_filtered (outfile, "\n\n");
+  }
+
   do_cleanups (cleanups);
 }
 
-void
-maintenance_print_objfiles (char *ignore, int from_tty)
+static void
+maintenance_print_objfiles (char *regexp, int from_tty)
 {
+  struct program_space *pspace;
   struct objfile *objfile;
 
   dont_repeat ();
 
-  immediate_quit++;
-  ALL_OBJFILES (objfile)
-    dump_objfile (objfile);
-  immediate_quit--;
-}
+  if (regexp)
+    re_comp (regexp);
 
+  ALL_PSPACES (pspace)
+    ALL_PSPACE_OBJFILES (pspace, objfile)
+      {
+	QUIT;
+	if (! regexp
+	    || re_exec (objfile_name (objfile)))
+	  dump_objfile (objfile);
+      }
+}
 
 /* List all the symbol tables whose names match REGEXP (optional).  */
-void
+
+static void
 maintenance_info_symtabs (char *regexp, int from_tty)
 {
+  struct program_space *pspace;
   struct objfile *objfile;
 
+  dont_repeat ();
+
   if (regexp)
     re_comp (regexp);
 
-  ALL_OBJFILES (objfile)
+  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)
-        if (! regexp
-            || re_exec (symtab->filename))
-          {
-            if (! printed_objfile_start)
-              {
-                printf_filtered ("{ objfile %s ", objfile->name);
-                wrap_here ("  ");
-                printf_filtered ("((struct objfile *) %p)\n", objfile);
-                printed_objfile_start = 1;
-              }
-
-            printf_filtered ("  { symtab %s ", symtab->filename);
-            wrap_here ("    ");
-            printf_filtered ("((struct symtab *) %p)\n", 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 *) %p)%s\n",
-                             symtab->blockvector,
-                             symtab->primary ? " (primary)" : "");
-            printf_filtered ("    debugformat %s\n", symtab->debugformat);
-            printf_filtered ("  }\n");
-          }
+      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.
 
-/* List all the partial symbol tables whose names match REGEXP (optional).  */
-void
-maintenance_info_psymtabs (char *regexp, int from_tty)
+   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;
 
-  if (regexp)
-    re_comp (regexp);
-
-  ALL_OBJFILES (objfile)
+  ALL_PSPACES (pspace)
+    ALL_PSPACE_OBJFILES (pspace, objfile)
     {
-      struct partial_symtab *psymtab;
+      struct compunit_symtab *cust;
 
       /* We don't want to print anything for this objfile until we
-         actually find a symtab whose name matches.  */
+         actually find something worth printing.  */
       int printed_objfile_start = 0;
 
-      ALL_OBJFILE_PSYMTABS (objfile, psymtab)
-        if (! regexp
-            || re_exec (psymtab->filename))
-          {
-            if (! printed_objfile_start)
-              {
-                printf_filtered ("{ objfile %s ", objfile->name);
-                wrap_here ("  ");
-                printf_filtered ("((struct objfile *) %p)\n", objfile);
-                printed_objfile_start = 1;
-              }
-
-            printf_filtered ("  { psymtab %s ", psymtab->filename);
-            wrap_here ("    ");
-            printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
-            printf_filtered ("    readin %s\n",
-                             psymtab->readin ? "yes" : "no");
-            printf_filtered ("    fullname %s\n",
-                             psymtab->fullname ? psymtab->fullname : "(null)");
-            printf_filtered ("    text addresses ");
-            deprecated_print_address_numeric (psymtab->textlow, 1, gdb_stdout);
-            printf_filtered (" -- ");
-            deprecated_print_address_numeric (psymtab->texthigh, 1, gdb_stdout);
-            printf_filtered ("\n");
-            printf_filtered ("    globals ");
-            if (psymtab->n_global_syms)
-              {
-                printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
-                                 (psymtab->objfile->global_psymbols.list
-                                  + psymtab->globals_offset),
-                                 psymtab->n_global_syms);
-              }
-            else
-              printf_filtered ("(none)\n");
-            printf_filtered ("    statics ");
-            if (psymtab->n_static_syms)
-              {
-                printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
-                                 (psymtab->objfile->static_psymbols.list
-                                  + psymtab->statics_offset),
-                                 psymtab->n_static_syms);
-              }
-            else
-              printf_filtered ("(none)\n");
-            printf_filtered ("    dependencies ");
-            if (psymtab->number_of_dependencies)
-              {
-                int i;
-
-                printf_filtered ("{\n");
-                for (i = 0; i < psymtab->number_of_dependencies; i++)
-                  {
-                    struct partial_symtab *dep = psymtab->dependencies[i];
-
-                    /* Note the string concatenation there --- no comma.  */
-                    printf_filtered ("      psymtab %s "
-                                     "((struct partial_symtab *) %p)\n",
-                                     dep->filename, dep);
-                  }
-                printf_filtered ("    }\n");
-              }
-            else
-              printf_filtered ("(none)\n");
-            printf_filtered ("  }\n");
-          }
+      ALL_OBJFILE_COMPUNITS (objfile, cust)
+	{
+	  int found_something = 0;
+	  struct symtab *symtab = compunit_primary_filetab (cust);
+
+	  QUIT;
+
+	  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 (objfile));
+		  wrap_here ("  ");
+		  printf_filtered ("((struct objfile *) %s)\n",
+				   host_address_to_string (objfile));
+		  printed_objfile_start = 1;
+		}
+	      printf_filtered ("  { symtab %s\n",
+			       symtab_to_filename_for_display (symtab));
+	      if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
+		printf_filtered ("    NULL blockvector\n");
+	      printf_filtered ("  }\n");
+	    }
+	}
 
       if (printed_objfile_start)
         printf_filtered ("}\n");
     }
 }
 
+/* Helper function for maintenance_expand_symtabs.
+   This is the name_matcher function for expand_symtabs_matching.  */
 
-/* Check consistency of psymtabs and symtabs.  */
+static int
+maintenance_expand_name_matcher (const char *symname, void *data)
+{
+  /* Since we're not searching on symbols, just return TRUE.  */
+  return 1;
+}
 
-void
-maintenance_check_symtabs (char *ignore, int from_tty)
+/* 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)
 {
-  struct symbol *sym;
-  struct partial_symbol **psym;
-  struct symtab *s = NULL;
-  struct partial_symtab *ps;
-  struct blockvector *bv;
+  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 block *b;
-  int length;
+  struct cleanup *cleanups;
+  char **argv;
+  char *regexp = NULL;
 
-  ALL_PSYMTABS (objfile, ps)
-  {
-    s = PSYMTAB_TO_SYMTAB (ps);
-    if (s == NULL)
-      continue;
-    bv = BLOCKVECTOR (s);
-    b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-    psym = ps->objfile->static_psymbols.list + ps->statics_offset;
-    length = ps->n_static_syms;
-    while (length--)
-      {
-	sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
-				   NULL, SYMBOL_DOMAIN (*psym));
-	if (!sym)
-	  {
-	    printf_filtered ("Static symbol `");
-	    puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
-	    printf_filtered ("' only found in ");
-	    puts_filtered (ps->filename);
-	    printf_filtered (" psymtab\n");
-	  }
-	psym++;
-      }
-    b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-    psym = ps->objfile->global_psymbols.list + ps->globals_offset;
-    length = ps->n_global_syms;
-    while (length--)
-      {
-	sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
-				   NULL, SYMBOL_DOMAIN (*psym));
-	if (!sym)
-	  {
-	    printf_filtered ("Global symbol `");
-	    puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
-	    printf_filtered ("' only found in ");
-	    puts_filtered (ps->filename);
-	    printf_filtered (" psymtab\n");
-	  }
-	psym++;
-      }
-    if (ps->texthigh < ps->textlow)
-      {
-	printf_filtered ("Psymtab ");
-	puts_filtered (ps->filename);
-	printf_filtered (" covers bad range ");
-	deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
-	printf_filtered (" - ");
-	deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
-	printf_filtered ("\n");
-	continue;
-      }
-    if (ps->texthigh == 0)
-      continue;
-    if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
-      {
-	printf_filtered ("Psymtab ");
-	puts_filtered (ps->filename);
-	printf_filtered (" covers ");
-	deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
-	printf_filtered (" - ");
-	deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
-	printf_filtered (" but symtab covers only ");
-	deprecated_print_address_numeric (BLOCK_START (b), 1, gdb_stdout);
-	printf_filtered (" - ");
-	deprecated_print_address_numeric (BLOCK_END (b), 1, gdb_stdout);
-	printf_filtered ("\n");
-      }
-  }
+  /* 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);
 }
 
 
@@ -1231,6 +1016,7 @@ static int
 block_depth (struct block *block)
 {
   int i = 0;
+
   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
     {
       i++;
@@ -1239,40 +1025,142 @@ block_depth (struct block *block)
 }
 
 
-/* Increase the space allocated for LISTP, which is probably
-   global_psymbols or static_psymbols. This space will eventually
-   be freed in free_objfile().  */
+/* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
+   single line table.  */
 
-void
-extend_psymbol_list (struct psymbol_allocation_list *listp,
-		     struct objfile *objfile)
+static int
+maintenance_print_one_line_table (struct symtab *symtab, void *data)
 {
-  int new_size;
-  if (listp->size == 0)
+  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
     {
-      new_size = 255;
-      listp->list = (struct partial_symbol **)
-	xmalloc (new_size * sizeof (struct partial_symbol *));
+      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;
+
+	  item = &linetable->item [i];
+	  printf_filtered (_("%-6d %6d %s\n"), i, item->line,
+			   core_addr_to_string (item->pc));
+	}
     }
-  else
+
+  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)
     {
-      new_size = listp->size * 2;
-      listp->list = (struct partial_symbol **)
-	xrealloc ((char *) listp->list,
-		  new_size * sizeof (struct partial_symbol *));
+      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);
+	    }
+	}
     }
-  /* Next assumes we only went one over.  Should be good if
-     program works correctly */
-  listp->next = listp->list + listp->size;
-  listp->size = new_size;
 }
 
+
+
+/* Do early runtime initializations.  */
 
-/* Do early runtime initializations. */
 void
 _initialize_symmisc (void)
 {
   std_in = stdin;
   std_out = stdout;
   std_err = stderr;
+
+  add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
+Print dump of current symbol definitions.\n\
+Usage: mt print symbols [-pc address] [--] [outfile]\n\
+       mt print symbols [-objfile objfile] [-source source] [--] [outfile]\n\
+Entries in the full symbol table are dumped to file OUTFILE,\n\
+or the terminal if OUTFILE is unspecified.\n\
+If ADDRESS is provided, dump only the file for that address.\n\
+If SOURCE is provided, dump only that file's symbols.\n\
+If OBJFILE is provided, dump only that file's minimal symbols."),
+	   &maintenanceprintlist);
+
+  add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
+Print dump of current minimal symbol definitions.\n\
+Usage: mt print msymbols [-objfile objfile] [--] [outfile]\n\
+Entries in the minimal symbol table are dumped to file OUTFILE,\n\
+or the terminal if OUTFILE is unspecified.\n\
+If OBJFILE is provided, dump only that file's minimal symbols."),
+	   &maintenanceprintlist);
+
+  add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
+	   _("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 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);
 }