gdb

	* symfile.c (reread_symbols): Update.
	* objfiles.h (struct objfile) <cp_namespace_symtab>: Remove
	field.
	* objfiles.c (allocate_objfile): Update.
	* cp-support.h (cp_check_possible_namespace_symbols): Don't
	declare.
	* cp-namespace.c (lookup_symbol_file): Don't call
	lookup_possible_namespace_symbol.
	(initialize_namespace_symtab, get_possible_namespace_block)
	(free_namespace_block, cp_check_possible_namespace_symbols)
	(check_possible_namespace_symbols_loop)
	(check_one_possible_namespace_symbol)
	(lookup_possible_namespace_symbol): Remove.
	(maintenance_cplus_namespace): Replace with notice.
	(_initialize_cp_namespace): Deprecate `maint cplus namespace'.
gdb/testsuite
	* gdb.cp/maint.exp (test_help): Update.
	(test_namespace): Likewise.

8 files changed, 37 insertions, 296 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 2f41d96..3430446 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,23 @@
 2011-04-04  Tom Tromey  <tromey@redhat.com>
 
+	* symfile.c (reread_symbols): Update.
+	* objfiles.h (struct objfile) <cp_namespace_symtab>: Remove
+	field.
+	* objfiles.c (allocate_objfile): Update.
+	* cp-support.h (cp_check_possible_namespace_symbols): Don't
+	declare.
+	* cp-namespace.c (lookup_symbol_file): Don't call
+	lookup_possible_namespace_symbol.
+	(initialize_namespace_symtab, get_possible_namespace_block)
+	(free_namespace_block, cp_check_possible_namespace_symbols)
+	(check_possible_namespace_symbols_loop)
+	(check_one_possible_namespace_symbol)
+	(lookup_possible_namespace_symbol): Remove.
+	(maintenance_cplus_namespace): Replace with notice.
+	(_initialize_cp_namespace): Deprecate `maint cplus namespace'.
+
+2011-04-04  Tom Tromey  <tromey@redhat.com>
+
 	* xcoffread.c (read_xcoff_symtab): Make `debugfmt' const.
 	* symtab.h (struct symtab) <producer, debugformat>: Now const.
 	* symmisc.c (free_symtab): Don't free debugformat.
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index bdbc215..030cfb9 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -49,24 +49,6 @@ static struct type *cp_lookup_transparent_type_loop (const char *name,
 						     const char *scope,
 						     int scope_len);
 
-static void initialize_namespace_symtab (struct objfile *objfile);
-
-static struct block *get_possible_namespace_block (struct objfile *objfile);
-
-static void free_namespace_block (struct symtab *symtab);
-
-static int check_possible_namespace_symbols_loop (const char *name,
-						  int len,
-						  struct objfile *objfile);
-
-static int check_one_possible_namespace_symbol (const char *name,
-						int len,
-						struct objfile *objfile);
-
-static struct symbol *lookup_possible_namespace_symbol (const char *name);
-
-static void maintenance_cplus_namespace (char *args, int from_tty);
-
 /* Check to see if SYMBOL refers to an object contained within an
    anonymous namespace; if so, add an appropriate using directive.  */
 
@@ -636,27 +618,7 @@ lookup_symbol_file (const char *name,
       sym = lookup_symbol_global (name, block, domain);
     }
 
-  if (sym != NULL)
-    return sym;
-
-  /* Now call "lookup_possible_namespace_symbol".  Symbols in here
-     claim to be associated to namespaces, but this claim might be
-     incorrect: the names in question might actually correspond to
-     classes instead of namespaces.  But if they correspond to
-     classes, then we should have found a match for them above.  So if
-     we find them now, they should be genuine.  */
-
-  /* FIXME: carlton/2003-06-12: This is a hack and should eventually
-     be deleted: see comments below.  */
-
-  if (domain == VAR_DOMAIN)
-    {
-      sym = lookup_possible_namespace_symbol (name);
-      if (sym != NULL)
-	return sym;
-    }
-
-  return NULL;
+  return sym;
 }
 
 /* Look up a type named NESTED_NAME that is nested inside the C++
@@ -784,243 +746,13 @@ cp_lookup_transparent_type_loop (const char *name,
   return basic_lookup_transparent_type (full_name);
 }
 
-/* Now come functions for dealing with symbols associated to
-   namespaces.  (They're used to store the namespaces themselves, not
-   objects that live in the namespaces.)  These symbols come in two
-   varieties: if we run into a DW_TAG_namespace DIE, then we know that
-   we have a namespace, so dwarf2read.c creates a symbol for it just
-   like normal.  But, unfortunately, versions of GCC through at least
-   3.3 don't generate those DIE's.  Our solution is to try to guess
-   their existence by looking at demangled names.  This might cause us
-   to misidentify classes as namespaces, however.  So we put those
-   symbols in a special block (one per objfile), and we only search
-   that block as a last resort.  */
-
-/* FIXME: carlton/2003-06-12: Once versions of GCC that generate
-   DW_TAG_namespace have been out for a year or two, we should get rid
-   of all of this "possible namespace" nonsense.  */
-
-/* Allocate everything necessary for the possible namespace block
-   associated to OBJFILE.  */
-
-static void
-initialize_namespace_symtab (struct objfile *objfile)
-{
-  struct symtab *namespace_symtab;
-  struct blockvector *bv;
-  struct block *bl;
-
-  namespace_symtab = allocate_symtab ("<<C++-namespaces>>", objfile);
-  namespace_symtab->language = language_cplus;
-  namespace_symtab->free_code = free_nothing;
-  namespace_symtab->dirname = NULL;
-
-  bv = obstack_alloc (&objfile->objfile_obstack,
-		      sizeof (struct blockvector)
-		      + FIRST_LOCAL_BLOCK * sizeof (struct block *));
-  BLOCKVECTOR_NBLOCKS (bv) = FIRST_LOCAL_BLOCK + 1;
-  BLOCKVECTOR (namespace_symtab) = bv;
-  
-  /* Allocate empty GLOBAL_BLOCK and STATIC_BLOCK.  */
-
-  bl = allocate_block (&objfile->objfile_obstack);
-  BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
-					NULL);
-  BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
-  bl = allocate_block (&objfile->objfile_obstack);
-  BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
-					NULL);
-  BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
-
-  /* Allocate the possible namespace block; we put it where the first
-     local block will live, though I don't think there's any need to
-     pretend that it's actually a local block (e.g. by setting
-     BLOCK_SUPERBLOCK appropriately).  We don't use the global or
-     static block because we don't want it searched during the normal
-     search of all global/static blocks in lookup_symbol: we only want
-     it used as a last resort.  */
-
-  /* NOTE: carlton/2003-09-11: I considered not associating the fake
-     symbols to a block/symtab at all.  But that would cause problems
-     with lookup_symbol's SYMTAB argument and with block_found, so
-     having a symtab/block for this purpose seems like the best
-     solution for now.  */
-
-  bl = allocate_block (&objfile->objfile_obstack);
-  BLOCK_DICT (bl) = dict_create_hashed_expandable ();
-  BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK) = bl;
-
-  namespace_symtab->free_func = free_namespace_block;
-
-  objfile->cp_namespace_symtab = namespace_symtab;
-}
-
-/* Locate the possible namespace block associated to OBJFILE,
-   allocating it if necessary.  */
-
-static struct block *
-get_possible_namespace_block (struct objfile *objfile)
-{
-  if (objfile->cp_namespace_symtab == NULL)
-    initialize_namespace_symtab (objfile);
-
-  return BLOCKVECTOR_BLOCK (BLOCKVECTOR (objfile->cp_namespace_symtab),
-			    FIRST_LOCAL_BLOCK);
-}
-
-/* Free the dictionary associated to the possible namespace block.  */
-
-static void
-free_namespace_block (struct symtab *symtab)
-{
-  struct block *possible_namespace_block;
-
-  possible_namespace_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
-						FIRST_LOCAL_BLOCK);
-  gdb_assert (possible_namespace_block != NULL);
-  dict_free (BLOCK_DICT (possible_namespace_block));
-}
-
-/* Ensure that there are symbols in the possible namespace block
-   associated to OBJFILE for all initial substrings of NAME that look
-   like namespaces or classes.  NAME should end in a member variable:
-   it shouldn't consist solely of namespaces.  */
-
-void
-cp_check_possible_namespace_symbols (const char *name,
-				     struct objfile *objfile)
-{
-  check_possible_namespace_symbols_loop (name,
-					 cp_find_first_component (name),
-					 objfile);
-}
-
-/* This is a helper loop for cp_check_possible_namespace_symbols; it
-   ensures that there are symbols in the possible namespace block
-   associated to OBJFILE for all namespaces that are initial
-   substrings of NAME of length at least LEN.  It returns 1 if a
-   previous loop had already created the shortest such symbol and 0
-   otherwise.
-
-   This function assumes that if there is already a symbol associated
-   to a substring of NAME of a given length, then there are already
-   symbols associated to all substrings of NAME whose length is less
-   than that length.  So if cp_check_possible_namespace_symbols has
-   been called once with argument "A::B::C::member", then that will
-   create symbols "A", "A::B", and "A::B::C".  If it is then later
-   called with argument "A::B::D::member", then the new call will
-   generate a new symbol for "A::B::D", but once it sees that "A::B"
-   has already been created, it doesn't bother checking to see if "A"
-   has also been created.  */
-
-static int
-check_possible_namespace_symbols_loop (const char *name, int len,
-				       struct objfile *objfile)
-{
-  if (name[len] == ':')
-    {
-      int done;
-      int next_len = len + 2;
-
-      next_len += cp_find_first_component (name + next_len);
-      done = check_possible_namespace_symbols_loop (name, next_len,
-						    objfile);
-
-      if (!done)
-	done = check_one_possible_namespace_symbol (name, len,
-						    objfile);
-
-      return done;
-    }
-  else
-    return 0;
-}
-
-/* Check to see if there's already a possible namespace symbol in
-   OBJFILE whose name is the initial substring of NAME of length LEN.
-   If not, create one and return 0; otherwise, return 1.  */
-
-static int
-check_one_possible_namespace_symbol (const char *name, int len,
-				     struct objfile *objfile)
-{
-  struct block *block = get_possible_namespace_block (objfile);
-  char *name_copy = alloca (len + 1);
-  struct symbol *sym;
-
-  memcpy (name_copy, name, len);
-  name_copy[len] = '\0';
-  sym = lookup_block_symbol (block, name_copy, VAR_DOMAIN);
-
-  if (sym == NULL)
-    {
-      struct type *type;
-
-      type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
-			name_copy, objfile);
-
-      TYPE_TAG_NAME (type) = TYPE_NAME (type);
-
-      sym = obstack_alloc (&objfile->objfile_obstack,
-			   sizeof (struct symbol));
-      memset (sym, 0, sizeof (struct symbol));
-      SYMBOL_SET_LANGUAGE (sym, language_cplus);
-      /* Note that init_type copied the name to the objfile's
-	 obstack.  */
-      SYMBOL_SET_NAMES (sym, TYPE_NAME (type), len, 0, objfile);
-      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-      SYMBOL_TYPE (sym) = type;
-      SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-
-      dict_add_symbol (BLOCK_DICT (block), sym);
-
-      return 0;
-    }
-  else
-    return 1;
-}
-
-/* Look for a symbol named NAME in all the possible namespace blocks.
-   If one is found, return it.  */
-
-static struct symbol *
-lookup_possible_namespace_symbol (const char *name)
-{
-  struct objfile *objfile;
-
-  ALL_OBJFILES (objfile)
-    {
-      struct symbol *sym;
-
-      sym = lookup_block_symbol (get_possible_namespace_block (objfile),
-				 name, VAR_DOMAIN);
-
-      if (sym != NULL)
-	return sym;
-    }
-
-  return NULL;
-}
-
-/* Print out all the possible namespace symbols.  */
+/* This used to do something but was removed when it became
+   obsolete.  */
 
 static void
 maintenance_cplus_namespace (char *args, int from_tty)
 {
-  struct objfile *objfile;
-
-  printf_unfiltered (_("Possible namespaces:\n"));
-  ALL_OBJFILES (objfile)
-    {
-      struct dict_iterator iter;
-      struct symbol *sym;
-
-      ALL_BLOCK_SYMBOLS (get_possible_namespace_block (objfile),
-			 iter, sym)
-	{
-	  printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
-	}
-    }
+  printf_unfiltered (_("The `maint namespace' command was removed.\n"));
 }
 
 /* Provide a prototype to silence -Wmissing-prototypes.  */
@@ -1029,8 +761,11 @@ extern initialize_file_ftype _initialize_cp_namespace;
 void
 _initialize_cp_namespace (void)
 {
-  add_cmd ("namespace", class_maintenance,
-	   maintenance_cplus_namespace,
-	   _("Print the list of possible C++ namespaces."),
-	   &maint_cplus_cmd_list);
+  struct cmd_list_element *cmd;
+
+  cmd = add_cmd ("namespace", class_maintenance,
+		 maintenance_cplus_namespace,
+		 _("Deprecated placeholder for removed functionality."),
+		 &maint_cplus_cmd_list);
+  deprecate_cmd (cmd, NULL);
 }
diff --git a/gdb/cp-support.h b/gdb/cp-support.h
index 5902dcb..57aa03a 100644
--- a/gdb/cp-support.h
+++ b/gdb/cp-support.h
@@ -173,9 +173,6 @@ extern struct type *cp_lookup_nested_type (struct type *parent_type,
 					   const char *nested_name,
 					   const struct block *block);
 
-extern void cp_check_possible_namespace_symbols (const char *name,
-						 struct objfile *objfile);
-
 struct type *cp_lookup_transparent_type (const char *name);
 
 /* Functions from cp-name-parser.y.  */
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index f3259dd..6c1c91a 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -247,10 +247,6 @@ allocate_objfile (bfd *abfd, int flags)
   objfile->sect_index_bss = -1;
   objfile->sect_index_rodata = -1;
 
-  /* We don't yet have a C++-specific namespace symtab.  */
-
-  objfile->cp_namespace_symtab = NULL;
-
   /* Add this file onto the tail of the linked list of other such files.  */
 
   objfile->next = NULL;
diff --git a/gdb/objfiles.h b/gdb/objfiles.h
index 275c2ac..04b6d47 100644
--- a/gdb/objfiles.h
+++ b/gdb/objfiles.h
@@ -389,13 +389,6 @@ struct objfile
     /* Place to stash various statistics about this objfile.  */
       OBJSTATS;
 
-    /* A symtab that the C++ code uses to stash special symbols
-       associated to namespaces.  */
-
-    /* FIXME/carlton-2003-06-27: Delete this in a few years once
-       "possible namespace symbols" go away.  */
-    struct symtab *cp_namespace_symtab;
-
     /* A linked list of symbols created when reading template types or
        function templates.  These symbols are not stored in any symbol
        table, so we have to keep them here to relocate them
diff --git a/gdb/symfile.c b/gdb/symfile.c
index 1478c83..4e1109e 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -2460,7 +2460,6 @@ reread_symbols (void)
 	  objfile->psymtabs = NULL;
 	  objfile->psymtabs_addrmap = NULL;
 	  objfile->free_psymtabs = NULL;
-	  objfile->cp_namespace_symtab = NULL;
 	  objfile->template_symbols = NULL;
 	  objfile->msymbols = NULL;
 	  objfile->deprecated_sym_private = NULL;
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 9723a04..9ae251b 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2011-04-04  Tom Tromey  <tromey@redhat.com>
+
+	* gdb.cp/maint.exp (test_help): Update.
+	(test_namespace): Likewise.
+
 2011-04-01  Joel Brobecker  <brobecker@adacore.com>
 
 	* gdb.ada/arrayptr/foo.adb: Add access to constrained array.
diff --git a/gdb/testsuite/gdb.cp/maint.exp b/gdb/testsuite/gdb.cp/maint.exp
index ea7111d..41c12a6 100644
--- a/gdb/testsuite/gdb.cp/maint.exp
+++ b/gdb/testsuite/gdb.cp/maint.exp
@@ -1,4 +1,4 @@
-# Copyright 2003, 2004, 2006 Free Software Foundation Inc.
+# Copyright 2003, 2004, 2006, 2011 Free Software Foundation Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@ if $tracelevel then {
 
 proc test_help {} {
     set first_component_help "Print the first class/namespace component of NAME"
-    set namespace_help "Print the list of possible C\\+\\+ namespaces"
+    set namespace_help "Deprecated placeholder for removed functionality."
 
     test_prefix_command_help {"maintenance cplus"} {
         "C\\+\\+ maintenance commands\.\[\r\n\]+"
@@ -110,9 +110,7 @@ proc test_first_component {} {
 }
 
 proc test_namespace {} {
-    # There's not a lot we can do to test this.
-
-    gdb_test "maint cp namespace" "Possible namespaces:"
+    gdb_test "maint cp namespace" "The `maint namespace' command was removed."
 }
 
 gdb_exit