Compute DECL_ASSEMBLER_NAME lazily.

	* tree.h (DECL_ASSEMBLER_NAME): Compute it lazily.
	(DECL_ASSEMBLER_NAME_SET_P): New macro.
	(SET_DECL_ASSEMBLER_NAME): Likewise.
	(COPY_DECL_ASSEMBLER_NAME): Likewise.
	(set_decl_assembler_name): Declare.
	(lang_set_decl_assembler_name): Likewise.
	* tree.c (lang_set_decl_assembler_name): New variab.e
	(set_decl_assembler_name): New function.
	(init_obstacks): Set lang_set_decl_assembler_name.
	(build_decl): Don't set DECL_ASSEMBLER_NAME.
	* c-decl.c (duplicate_decls): Use SET_DECL_ASSEMBLER_NAME,
	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
	where it's not necessary.
	(builtin_function): Likewise.
	(finish_decl): Likewise.
	* dbxout.c (dbxout_type_methods): Likewise.
	* ggc-common.c (ggc_mark_trees): Likewise.
	* profile.c (output_func_start_profiler): Likewise.
	* varasm.c (make_decl_rtl): Likewise.

	* class.c (get_vtable_decl): Use SET_DECL_ASSEMBLER_NAME,
	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
	where it's not necessary.
	(add_method): Remove optimization involving comparison of
	DECL_ASSEMBLER_NAME.
	(build_vtbl_or_vbase_field): Use SET_DECL_ASSEMBLER_NAME,
	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
	where it's not necessary.
	(check_methods): Likewise.
	(build_clone): Likewise.
	(built_vtt): Likewise.
	* cp-tree.h (DECL_NEEDED_P): Likewise.
	* decl.c (pushtag): Likewise.
	(duplicate_decls): Likewise.
	(pushdecl): Likewise.
	(builtin_function): Likewise.
	(build_library_fn_1): Set DECL_LANGUAGE for library functions.
	(build_cp_library_fn): Likewise.
	(maybe_commonize_var): Use SET_DECL_ASSEMBLER_NAME,
	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
	where it's not necessary.
	(make_rtl_for_nonlocal_decl): Likewise.
	(cp_finish_decl): Likewise.
	(grokfndecl): Likewise.
	(grokvardecl): Likewise.
	(grokdeclarator): Likewise.
	(start_function): Likewise.
	(cp_missing_return_ok_p): Likewise.
	* decl2.c (grokclassfn): Likewise.
	(check_classfn): Likewise.
	(finish_static_data_member_decl): Likewise.
	(grokfield): Likewise.
	* error.c (GLOBAL_IORD_P): Remove.
	(dump_global_iord): Improve output.
	(dump_decl): Avoid using DECL_ASSEMBLER_NAME.
	* except.c (nothrow_libfn_p): Summarily reject any function not in
	namespace-scope.
	* init.c (build_java_class_ref): Don't explicitly set
	DECL_ASSEMBLER_NAME after calling mangle_decl.
	* mangle.c (mangle_decl_string): Handle extern "C" functions.
	(mangle_decl): Set the DECL_ASSEMBLER_NAME for the decl.
	* method.c (set_mangled_name_for_decl): Don't explicitly set
	DECL_ASSEMBLER_NAME after calling mangle_decl.
	(make_thunk): Explicitly set the DECL_ASSEMBLER_NAME and
	IDENTIFIER_GLOBAL_VALUE for the thunk.
	* pt.c (set_mangled_name_for_template_decl): Remove.
	(check_explicit_specialization): Don't use it.
	(looup_template_class): Don't set DECL_ASSEMBLER_NAME.
	(tsubst_friend_function): Likewise.
	(tsubst_decl): Likewise.
	(regenerate_decl_from_template): Use COPY_DECL_ASSEMBLER_NAME.
	* rtti.c (get_tinfo_decl): Use SET_DECL_ASSEMBLER_NAME,
	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
	where it's not necessary.
	(tinfo_base_init): Likewise.
	(create_real_tinfo_var): Likewise.
	* search.c (looup_field_1): Likewise.
	* semantics.c (finish_named_return_value): Likewise.
	* tree.c (init_tree): Set lang_set_decl_assembler_name.

	* com.c (builtin_function): Use SET_DECL_ASSEMBLER_NAME.

	* class.c (build_class_ref): Use SET_DECL_ASSEMBLER_NAME.
	(layout_class): Likewise.
	(layout_class_method): Likewise.
	(emit_register_classes): Likewise.
	* decl.c (builtin_function): Likewise.
	(give_name_to_locals): Likewise.

From-SVN: r40642

31 files changed, 300 insertions, 346 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 0eb39de..2050449 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,26 @@
 2001-03-19  Mark Mitchell  <mark@codesourcery.com>
 
+	Compute DECL_ASSEMBLER_NAME lazily.
+	* tree.h (DECL_ASSEMBLER_NAME): Compute it lazily.
+	(DECL_ASSEMBLER_NAME_SET_P): New macro.
+	(SET_DECL_ASSEMBLER_NAME): Likewise.
+	(COPY_DECL_ASSEMBLER_NAME): Likewise.
+	(set_decl_assembler_name): Declare.
+	(lang_set_decl_assembler_name): Likewise.
+	* tree.c (lang_set_decl_assembler_name): New variab.e
+	(set_decl_assembler_name): New function.
+	(init_obstacks): Set lang_set_decl_assembler_name.
+	(build_decl): Don't set DECL_ASSEMBLER_NAME.
+	* c-decl.c (duplicate_decls): Use SET_DECL_ASSEMBLER_NAME,
+	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
+	where it's not necessary.
+	(builtin_function): Likewise.
+	(finish_decl): Likewise.
+	* dbxout.c (dbxout_type_methods): Likewise.
+	* ggc-common.c (ggc_mark_trees): Likewise.
+	* profile.c (output_func_start_profiler): Likewise.
+	* varasm.c (make_decl_rtl): Likewise.
+
 	* cse.c (find_comparison_args): Update documentation.  Fix
 	mishandling of COMPARE operations.
 
diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index fead392..1d51725 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -1902,7 +1902,7 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
 
       /* Copy the assembler name.
 	 Currently, it can only be defined in the prototype.  */
-      DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
+      COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
 
       if (TREE_CODE (newdecl) == FUNCTION_DECL)
 	{
@@ -3186,7 +3186,7 @@ builtin_function (name, type, function_code, class, library_name)
   if (flag_traditional && name[0] != '_')
     DECL_BUILT_IN_NONANSI (decl) = 1;
   if (library_name)
-    DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+    SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
   make_decl_rtl (decl, NULL_PTR);
   pushdecl (decl);
   DECL_BUILT_IN_CLASS (decl) = class;
@@ -3599,7 +3599,7 @@ finish_decl (decl, init, asmspec_tree)
     {
       DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
       SET_DECL_RTL (decl, NULL_RTX);
-      DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+      SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
     }
 
   /* Output the assembler code and/or RTL code for variables and functions,
@@ -3627,7 +3627,7 @@ finish_decl (decl, init, asmspec_tree)
 	{
 	  if (asmspec)
 	    {
-	      DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+	      SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
 	      DECL_C_HARD_REGISTER (decl) = 1;
 	    }
 	  add_decl_stmt (decl);
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 429a570..15ff7b5 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,65 @@
+2001-03-19  Mark Mitchell  <mark@codesourcery.com>
+
+	* class.c (get_vtable_decl): Use SET_DECL_ASSEMBLER_NAME,
+	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
+	where it's not necessary.
+	(add_method): Remove optimization involving comparison of
+	DECL_ASSEMBLER_NAME.
+	(build_vtbl_or_vbase_field): Use SET_DECL_ASSEMBLER_NAME,
+	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
+	where it's not necessary.
+	(check_methods): Likewise.
+	(build_clone): Likewise.
+	(built_vtt): Likewise.
+	* cp-tree.h (DECL_NEEDED_P): Likewise.
+	* decl.c (pushtag): Likewise.
+	(duplicate_decls): Likewise.
+	(pushdecl): Likewise.
+	(builtin_function): Likewise.
+	(build_library_fn_1): Set DECL_LANGUAGE for library functions.
+	(build_cp_library_fn): Likewise.
+	(maybe_commonize_var): Use SET_DECL_ASSEMBLER_NAME,
+	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
+	where it's not necessary.
+	(make_rtl_for_nonlocal_decl): Likewise.
+	(cp_finish_decl): Likewise.
+	(grokfndecl): Likewise.
+	(grokvardecl): Likewise.
+	(grokdeclarator): Likewise.
+	(start_function): Likewise.
+	(cp_missing_return_ok_p): Likewise.
+	* decl2.c (grokclassfn): Likewise.
+	(check_classfn): Likewise.
+	(finish_static_data_member_decl): Likewise.
+	(grokfield): Likewise.
+	* error.c (GLOBAL_IORD_P): Remove.
+	(dump_global_iord): Improve output.
+	(dump_decl): Avoid using DECL_ASSEMBLER_NAME.
+	* except.c (nothrow_libfn_p): Summarily reject any function not in
+	namespace-scope.
+	* init.c (build_java_class_ref): Don't explicitly set
+	DECL_ASSEMBLER_NAME after calling mangle_decl.
+	* mangle.c (mangle_decl_string): Handle extern "C" functions.
+	(mangle_decl): Set the DECL_ASSEMBLER_NAME for the decl.
+	* method.c (set_mangled_name_for_decl): Don't explicitly set
+	DECL_ASSEMBLER_NAME after calling mangle_decl.
+	(make_thunk): Explicitly set the DECL_ASSEMBLER_NAME and
+	IDENTIFIER_GLOBAL_VALUE for the thunk.
+	* pt.c (set_mangled_name_for_template_decl): Remove.
+	(check_explicit_specialization): Don't use it.
+	(looup_template_class): Don't set DECL_ASSEMBLER_NAME.
+	(tsubst_friend_function): Likewise.
+	(tsubst_decl): Likewise.
+	(regenerate_decl_from_template): Use COPY_DECL_ASSEMBLER_NAME.
+	* rtti.c (get_tinfo_decl): Use SET_DECL_ASSEMBLER_NAME,
+	COPY_DECL_ASSEMBLER_NAME, etc.  Don't set DECL_ASSEMBLER_NAME
+	where it's not necessary.
+	(tinfo_base_init): Likewise.
+	(create_real_tinfo_var): Likewise.
+	* search.c (looup_field_1): Likewise.
+	* semantics.c (finish_named_return_value): Likewise.
+	* tree.c (init_tree): Set lang_set_decl_assembler_name.
+	
 2001-03-15  Gabriel Dos Reis  <gdr@codesourcery.com>
 
 	Correct semantics restrictions checking in throw-expression.
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 0828852..cf3b666 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -760,6 +760,7 @@ get_vtable_decl (type, complete)
     }
   
   decl = build_vtable (type, name, void_type_node);
+  SET_DECL_ASSEMBLER_NAME (decl, name);
   decl = pushdecl_top_level (decl);
   my_friendly_assert (IDENTIFIER_GLOBAL_VALUE (name) == decl,
 		      20000517);
@@ -1310,17 +1311,9 @@ add_method (type, method, error_p)
 				  fn, method);
 		    }
 		}
-
-	      /* Since this is an ordinary function in a
-		 non-template class, it's mangled name can be used
-		 as a unique identifier.  This technique is only
-		 an optimization; we would get the same results if
-		 we just used decls_match here.  */
-	      if (DECL_ASSEMBLER_NAME (fn) 
-		  != DECL_ASSEMBLER_NAME (method))
-		continue;
 	    }
-	  else if (!decls_match (fn, method))
+
+	  if (!decls_match (fn, method))
 	    continue;
 
 	  /* There has already been a declaration of this method
@@ -3693,7 +3686,7 @@ build_vtbl_or_vbase_field (name, assembler_name, type, class_type, fcontext,
 
   /* Build the FIELD_DECL.  */
   field = build_decl (FIELD_DECL, name, type);
-  DECL_ASSEMBLER_NAME (field) = assembler_name;
+  SET_DECL_ASSEMBLER_NAME (field, assembler_name);
   DECL_VIRTUAL_P (field) = 1;
   DECL_ARTIFICIAL (field) = 1;
   DECL_FIELD_CONTEXT (field) = class_type;
@@ -4120,7 +4113,8 @@ check_methods (t)
       GNU_xref_member (current_class_name, x);
 
       /* If this was an evil function, don't keep it in class.  */
-      if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
+      if (DECL_ASSEMBLER_NAME_SET_P (x) 
+	  && IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
 	continue;
 
       check_for_override (x, t);
@@ -4184,7 +4178,6 @@ build_clone (fn, name)
   DECL_ABSTRACT_ORIGIN (clone) = fn;
   /* Reset the function name.  */
   DECL_NAME (clone) = name;
-  DECL_ASSEMBLER_NAME (clone) = DECL_NAME (clone);
   /* There's no pending inline data for this function.  */
   DECL_PENDING_INLINE_INFO (clone) = NULL;
   DECL_PENDING_INLINE_P (clone) = 0;
@@ -4261,9 +4254,6 @@ build_clone (fn, name)
 	}
     }
 
-  /* Mangle the function name.  */
-  set_mangled_name_for_decl (clone);
-
   /* Create the RTL for this function.  */
   SET_DECL_RTL (clone, NULL_RTX);
   rest_of_decl_compilation (clone, NULL, /*top_level=*/1, at_eof);
@@ -6823,6 +6813,7 @@ build_vtt (t)
 				 
   /* Now, build the VTT object itself.  */
   vtt = build_vtable (t, get_vtt_name (t), type);
+  SET_DECL_ASSEMBLER_NAME (vtt, DECL_NAME (vtt));
   pushdecl_top_level (vtt);
   initialize_array (vtt, inits);
 }
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 19bb167..eb4bc7c 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -1904,9 +1904,10 @@ struct lang_decl
    just been used somewhere, even if it's not really needed.  We need
    anything that isn't comdat, but we don't know for sure whether or
    not something is comdat until end-of-file.  */
-#define DECL_NEEDED_P(DECL)					\
-  ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL))	\
-   || (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME ((DECL))))	\
+#define DECL_NEEDED_P(DECL)						\
+  ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL))		\
+   || (DECL_ASSEMBLER_NAME_SET_P (DECL)					\
+       && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME ((DECL))))	\
    || (flag_syntax_only && TREE_USED ((DECL))))
 
 /* Non-zero iff DECL is memory-based.  The DECL_RTL of
@@ -4531,7 +4532,7 @@ extern void GNU_xref_member			PARAMS ((tree, tree));
 
 /* in mangle.c */
 extern void init_mangle                         PARAMS ((void));
-extern tree mangle_decl                         PARAMS ((tree));
+extern void mangle_decl                         PARAMS ((tree));
 extern const char *mangle_type_string           PARAMS ((tree));
 extern tree mangle_type                         PARAMS ((tree));
 extern tree mangle_typeinfo_for_type            PARAMS ((tree));
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 8a5857a..f540cc5 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -2827,7 +2827,6 @@ pushtag (name, type, globalize)
 	    DECL_IGNORED_P (d) = 1;
 
 	  TYPE_CONTEXT (type) = DECL_CONTEXT (d);
-	  DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
 
 	  /* If this is a local class, keep track of it.  We need this
 	     information for name-mangling, and so that it is possible to find
@@ -2838,9 +2837,6 @@ pushtag (name, type, globalize)
 	      && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
 	      && !processing_template_decl)
 	    VARRAY_PUSH_TREE (local_classes, type);
-
-	  if (!uses_template_parms (type))
-	    DECL_ASSEMBLER_NAME (d) = mangle_type (type);
         }
       if (b->parm_flag == 2)
 	{
@@ -3161,7 +3157,7 @@ duplicate_decls (newdecl, olddecl)
 	     will be banished.  */
 	  DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
 	  SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
-	  DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
+	  COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
 	  SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
 				       newdecl);
 	}
@@ -3633,7 +3629,7 @@ duplicate_decls (newdecl, olddecl)
       if (! types_match)
 	{
 	  DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
-	  DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
+	  COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
 	  SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
 	}
       if (! types_match || new_defines_function)
@@ -3683,7 +3679,7 @@ duplicate_decls (newdecl, olddecl)
   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
-  DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
+  COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
 
   if (TREE_CODE (newdecl) == FUNCTION_DECL)
     {
@@ -3846,8 +3842,7 @@ pushdecl (x)
 	  if (TREE_CODE (x) == FUNCTION_DECL)
 	    for (match = t; match; match = OVL_NEXT (match))
 	      {
-		if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
-		    == DECL_ASSEMBLER_NAME (x))
+		if (decls_match (OVL_CURRENT (match), x))
 		  break;
 	      }
 	  else
@@ -4028,32 +4023,15 @@ pushdecl (x)
 	  if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
 	    TREE_PUBLIC (name) = 1;
 
-	  /* Bind the mangled name for the entity.  In the future, we
-	     should not need to do this; mangled names are an
-	     implementation detail of which the front-end should not
-	     need to be aware.  */
-	  if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
-		&& t != NULL_TREE)
-	      /* For an ordinary function, we create a binding from
-		 the mangled name (i.e., NAME) to the DECL.  But, for
-		 an `extern "C"' function, the mangled name and the
-		 ordinary name are the same so we need not do this.  */
-	      && !DECL_EXTERN_C_FUNCTION_P (x))
-	    {
-	      tree mangled_name;
-
-	      if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
-		  || TREE_CODE (x) == NAMESPACE_DECL)
-		mangled_name = name;
-	      else
-		mangled_name = DECL_ASSEMBLER_NAME (x);
-
-	      if (TREE_CODE (x) == FUNCTION_DECL)
-		my_friendly_assert
-		  ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
-		  || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
-	      SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
-	    }
+ 	  /* Bind the name for the entity.  */
+ 	  if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
+  		&& t != NULL_TREE)
+ 	      && (TREE_CODE (x) == TYPE_DECL
+ 		  || TREE_CODE (x) == VAR_DECL
+ 		  || TREE_CODE (x) == NAMESPACE_DECL
+ 		  || TREE_CODE (x) == CONST_DECL
+ 		  || TREE_CODE (x) == TEMPLATE_DECL))
+ 	    SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
 
 	  /* Don't forget if the function was used via an implicit decl.  */
 	  if (IDENTIFIER_IMPLICIT_DECL (name)
@@ -6670,7 +6648,8 @@ builtin_function (name, type, code, class, libname)
      we cannot change DECL_ASSEMBLER_NAME until we have installed this
      function in the namespace.  */
   if (libname)
-    DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
+    SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
+  make_decl_rtl (decl, NULL);
 
   /* Warn if a function in the namespace for users
      is used without an occasion to consider it declared.  */
@@ -6695,6 +6674,7 @@ build_library_fn_1 (name, operator_code, type)
   DECL_ARTIFICIAL (fn) = 1;
   TREE_NOTHROW (fn) = 1;
   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
+  DECL_LANGUAGE (fn) = lang_c;
   return fn;
 }
 
@@ -6721,6 +6701,7 @@ build_cp_library_fn (name, operator_code, type)
   tree fn = build_library_fn_1 (name, operator_code, type);
   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
+  DECL_LANGUAGE (fn) = lang_cplusplus;
   set_mangled_name_for_decl (fn);
   return fn;
 }
@@ -7534,9 +7515,7 @@ maybe_commonize_var (decl)
 	  /* else we lose. We can only do this if we can use common,
 	     which we can't if it has been initialized.  */
 
-	  if (TREE_PUBLIC (decl))
-	    DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
-	  else
+	  if (!TREE_PUBLIC (decl))
 	    {
 	      cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
 	      cp_warning_at ("  you can work around this by removing the initializer", decl);
@@ -7721,7 +7700,7 @@ make_rtl_for_nonlocal_decl (decl, init, asmspec)
 
   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
   if (asmspec)
-    DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+    SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
 
   /* We don't create any RTL for local variables.  */
   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
@@ -7751,12 +7730,15 @@ make_rtl_for_nonlocal_decl (decl, init, asmspec)
       defer_p = 1;
     }
 
-  /* If we're deferring the variable, just make RTL.  Do not actually
-     emit the variable.  */
-  if (defer_p)
+  /* If we're deferring the variable, we only need to make RTL if
+     there's an ASMSPEC.  Otherwise, we'll lazily create it later when
+     we need it.  (There's no way to lazily create RTL for things that
+     have assembly specs because the information about the specifier
+     isn't stored in the tree, yet)  */
+  if (defer_p && asmspec)
     make_decl_rtl (decl, asmspec);
   /* If we're not deferring, go ahead and assemble the variable.  */
-  else
+  else if (!defer_p)
     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
 }
 
@@ -8034,7 +8016,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags)
       /* This must override the asm specifier which was placed by
 	 grokclassfn.  Lay this out fresh.  */
       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
-      DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+      SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
       make_decl_rtl (decl, asmspec);
     }
 
@@ -8858,12 +8840,6 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
   if (has_default_arg)
     add_defarg_fn (decl);
 
-  /* Plain overloading: will not be grok'd by grokclassfn.  */
-  if (! ctype && ! processing_template_decl
-      && (! DECL_EXTERN_C_P (decl) || DECL_OVERLOADED_OPERATOR_P (decl))
-      && ! DECL_USE_TEMPLATE (decl))
-    set_mangled_name_for_decl (decl);
-
   if (funcdef_flag)
     /* Make the init_value nonzero so pushdecl knows this is not
        tentative.  error_mark_node is replaced later with the BLOCK.  */
@@ -8968,10 +8944,6 @@ grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
       type = TREE_TYPE (type);
       decl = build_lang_decl (VAR_DECL, declarator, type);
       DECL_CONTEXT (decl) = basetype;
-      /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
-	 templates.  */
-      if (!uses_template_parms (decl))
-	DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
     }
   else
     {
@@ -8996,7 +8968,10 @@ grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
 
       context = DECL_CONTEXT (decl);
       if (declarator && context && current_lang_name != lang_name_c)
-	DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
+	/* We can't mangle lazily here because we don't have any
+	   way to recover whether or not a variable was `extern
+	   "C"' later.  */
+	mangle_decl (decl);
     }
 
   if (in_namespace)
@@ -11005,8 +10980,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	    DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
 	      = TYPE_IDENTIFIER (type);
 
-	  DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
-
 	  /* FIXME remangle member functions; member functions of a
 	     type with external linkage have external linkage.  */
 	}
@@ -13537,19 +13510,10 @@ start_function (declspecs, declarator, attrs, flags)
   if (attrs)
     cplus_decl_attributes (decl1, NULL_TREE, attrs);
 
-  /* We need to do this even if we aren't expanding yet so that
-     assemble_external works.  */
-  make_decl_rtl (decl1, NULL);
-
   /* Promote the value to int before returning it.  */
   if (C_PROMOTING_INTEGER_TYPE_P (restype))
     restype = type_promotes_to (restype);
 
-  /* If this fcn was already referenced via a block-scope `extern' decl
-     (or an implicit decl), propagate certain information about the usage.  */
-  if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
-    TREE_ADDRESSABLE (decl1) = 1;
-
   if (DECL_RESULT (decl1) == NULL_TREE)
     {
       DECL_RESULT (decl1)
@@ -14488,5 +14452,5 @@ cp_missing_noreturn_ok_p (decl)
      tree decl;
 {
   /* A missing noreturn is ok for the `main' function.  */
-  return MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
+  return DECL_MAIN_P (decl);
 }
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index b60b669..1487a5b 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -1061,17 +1061,17 @@ grokclassfn (ctype, function, flags, quals)
   DECL_ARGUMENTS (function) = last_function_parms;
   DECL_CONTEXT (function) = ctype;
 
+  if (flags == DTOR_FLAG)
+    DECL_DESTRUCTOR_P (function) = 1;
+
   if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
     maybe_retrofit_in_chrg (function);
 
   if (flags == DTOR_FLAG)
     {
       DECL_DESTRUCTOR_P (function) = 1;
-      set_mangled_name_for_decl (function);
       TYPE_HAS_DESTRUCTOR (ctype) = 1;
     }
-  else
-    set_mangled_name_for_decl (function);
 }
 
 /* Work on the expr used by alignof (this is only called by the parser).  */
@@ -1436,22 +1436,6 @@ check_classfn (ctype, function)
 		   fndecls = OVL_NEXT (fndecls))
 		{
 		  fndecl = OVL_CURRENT (fndecls);
-		  /* The DECL_ASSEMBLER_NAME for a TEMPLATE_DECL, or
-		     for a for member function of a template class, is
-		     not mangled, so the check below does not work
-		     correctly in that case.  Since mangled destructor
-		     names do not include the type of the arguments,
-		     we can't use this short-cut for them, either.
-		     (It's not legal to declare arguments for a
-		     destructor, but some people try.)  */
-		  if (!DECL_DESTRUCTOR_P (function)
-		      && (DECL_ASSEMBLER_NAME (function)
-			  != DECL_NAME (function))
-		      && (DECL_ASSEMBLER_NAME (fndecl)
-			  != DECL_NAME (fndecl))
-		      && (DECL_ASSEMBLER_NAME (function) 
-			  == DECL_ASSEMBLER_NAME (fndecl)))
-		    return fndecl;
 
 		  /* We cannot simply call decls_match because this
 		     doesn't work for static member functions that are 
@@ -1525,11 +1509,6 @@ finish_static_data_member_decl (decl, init, asmspec_tree, flags)
      tree asmspec_tree;
      int flags;
 {
-  const char *asmspec = 0;
-
-  if (asmspec_tree)
-    asmspec = TREE_STRING_POINTER (asmspec_tree);
-
   my_friendly_assert (TREE_PUBLIC (decl), 0);
 
   DECL_CONTEXT (decl) = current_class_type;
@@ -1538,11 +1517,9 @@ finish_static_data_member_decl (decl, init, asmspec_tree, flags)
      decl of our TREE_CHAIN.  Instead, we modify cp_finish_decl to do
      the right thing, namely, to put this decl out straight away.  */
   /* current_class_type can be NULL_TREE in case of error.  */
-  if (!asmspec && current_class_type)
-    {
-      DECL_INITIAL (decl) = error_mark_node;
-      DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
-    }
+  if (!asmspec_tree && current_class_type)
+    DECL_INITIAL (decl) = error_mark_node;
+
   if (! processing_template_decl)
     {
       if (!pending_statics)
@@ -1672,12 +1649,6 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
       if (CLASS_TYPE_P (TREE_TYPE (value)))
         CLASSTYPE_GOT_SEMICOLON (TREE_TYPE (value)) = 1;
       
-      /* Now that we've updated the context, we need to remangle the
-	 name for this TYPE_DECL.  */
-      DECL_ASSEMBLER_NAME (value) = DECL_NAME (value);
-      if (!uses_template_parms (value)) 
-	DECL_ASSEMBLER_NAME (value) = mangle_type (TREE_TYPE (value));
-
       if (processing_template_decl)
 	value = push_template_decl (value);
 
@@ -1776,7 +1747,7 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
 	  /* This must override the asm specifier which was placed
 	     by grokclassfn.  Lay this out fresh.  */
 	  SET_DECL_RTL (value, NULL_RTX);
-	  DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
+	  SET_DECL_ASSEMBLER_NAME (value, get_identifier (asmspec));
 	}
       cp_finish_decl (value, init, asmspec_tree, flags);
 
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 0ec7405..0ab06fa 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -883,19 +883,15 @@ ident_fndecl (t)
 #  endif
 #endif
 
-#define GLOBAL_IORD_P(NODE) \
-  ! strncmp (IDENTIFIER_POINTER(NODE), GLOBAL_THING, sizeof (GLOBAL_THING) - 1)
-
 static void
 dump_global_iord (t)
      tree t;
 {
-  const char *name = IDENTIFIER_POINTER (t);
   const char *p = NULL;
 
-  if (name [sizeof (GLOBAL_THING) - 1] == 'I')
+  if (DECL_GLOBAL_CTOR_P (t))
     p = "initializers";
-  else if (name [sizeof (GLOBAL_THING) - 1] == 'D')
+  else if (DECL_GLOBAL_DTOR_P (t))
     p = "destructors";
   else
     my_friendly_abort (352);
@@ -1041,8 +1037,8 @@ dump_decl (t, flags)
       /* Fall through.  */
 
     case FUNCTION_DECL:
-      if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t)))
-	dump_global_iord (DECL_ASSEMBLER_NAME (t));
+      if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
+	dump_global_iord (t);
       else if (! DECL_LANG_SPECIFIC (t))
 	print_identifier (scratch_buffer, "<internal>");
       else
diff --git a/gcc/cp/except.c b/gcc/cp/except.c
index 595d3d6..fd99a93 100644
--- a/gcc/cp/except.c
+++ b/gcc/cp/except.c
@@ -1121,6 +1121,7 @@ nothrow_libfn_p (fn)
 
   if (TREE_PUBLIC (fn)
       && DECL_EXTERNAL (fn)
+      && DECL_NAMESPACE_SCOPE_P (fn)
       && DECL_EXTERN_C_P (fn))
     /* OK */;
   else
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 61e2d4f..f680ee0 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2219,7 +2219,8 @@ build_java_class_ref (type)
     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
       if (DECL_NAME (field) == CL_suffix)
 	{
-	  name = mangle_decl (field);
+	  mangle_decl (field);
+	  name = DECL_ASSEMBLER_NAME (field);
 	  break;
 	}
     if (!field)
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index 6736d1e..4d63f76 100644
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -2069,6 +2069,17 @@ mangle_decl_string (decl)
 
   if (TREE_CODE (decl) == TYPE_DECL)
     write_type (TREE_TYPE (decl));
+  else if (/* The names of `extern "C"' functions are not mangled.  */
+	   (TREE_CODE (decl) == FUNCTION_DECL 
+	    /* If there's no DECL_LANG_SPECIFIC, it's a function built
+	       by language-independent code, which never builds
+	       functions with C++ linkage.  */
+	    && (!DECL_LANG_SPECIFIC (decl) 
+		|| DECL_EXTERN_C_FUNCTION_P (decl)))
+	   /* The names of global variables aren't mangled either.  */
+	   || (TREE_CODE (decl) == VAR_DECL
+	       && CP_DECL_CONTEXT (decl) == global_namespace))
+    write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
   else
     {
       write_mangled_name (decl);
@@ -2089,11 +2100,13 @@ mangle_decl_string (decl)
 
 /* Create an identifier for the external mangled name of DECL.  */
 
-tree
+void
 mangle_decl (decl)
      tree decl;
 {
-  return get_identifier (mangle_decl_string (decl));
+  tree id = get_identifier (mangle_decl_string (decl));
+
+  SET_DECL_ASSEMBLER_NAME (decl, id);
 }
 
 /* Generate the mangled representation of TYPE.  */
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index dad5f7d..5f917d5 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -90,7 +90,7 @@ set_mangled_name_for_decl (decl)
     /* There's no need to mangle the name of a template function.  */
     return;
 
-  DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
+  mangle_decl (decl);
 }
 
 
@@ -346,6 +346,7 @@ make_thunk (function, delta, vcall_index, generate_with_vtable_p)
       thunk = build_decl (FUNCTION_DECL, thunk_id, TREE_TYPE (func_decl));
       DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (func_decl);
       copy_lang_decl (func_decl);
+      SET_DECL_ASSEMBLER_NAME (thunk, thunk_id);
       DECL_CONTEXT (thunk) = DECL_CONTEXT (func_decl);
       TREE_READONLY (thunk) = TREE_READONLY (func_decl);
       TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (func_decl);
@@ -373,6 +374,7 @@ make_thunk (function, delta, vcall_index, generate_with_vtable_p)
       DECL_DEFERRED_FN (thunk) = 0;
       /* So that finish_file can write out any thunks that need to be: */
       pushdecl_top_level (thunk);
+      SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk);
     }
   return thunk;
 }
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 3fa1cde..1644f73 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -144,7 +144,6 @@ static tree tsubst_template_parms PARAMS ((tree, tree, int));
 static void regenerate_decl_from_template PARAMS ((tree, tree));
 static tree most_specialized PARAMS ((tree, tree, tree));
 static tree most_specialized_class PARAMS ((tree, tree));
-static void set_mangled_name_for_template_decl PARAMS ((tree));
 static int template_class_depth_real PARAMS ((tree, int));
 static tree tsubst_aggr_type PARAMS ((tree, tree, int, tree, int));
 static tree tsubst_decl PARAMS ((tree, tree, tree));
@@ -1678,24 +1677,6 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 	  TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
 	  TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
 
-	  /* Mangle the function name appropriately.  Note that we do
-	     not mangle specializations of non-template member
-	     functions of template classes, e.g. with
-
-	       template <class T> struct S { void f(); }
-
-	     and given the specialization 
-
-	       template <> void S<int>::f() {}
-
-	     we do not mangle S<int>::f() here.  That's because it's
-	     just an ordinary member function and doesn't need special
-	     treatment.  We do this here so that the ordinary,
-	     non-template, name-mangling algorithm will not be used
-	     later.  */
-	  if (is_member_template (tmpl) || ctype == NULL_TREE)
-	    set_mangled_name_for_template_decl (decl);
-
 	  if (is_friend && !have_def)
 	    /* This is not really a declaration of a specialization.
 	       It's just the name of an instantiation.  But, it's not
@@ -4220,11 +4201,8 @@ lookup_template_class (d1, arglist, in_decl, context, entering_scope, complain)
 	 is set up.  */
       if (TREE_CODE (t) != ENUMERAL_TYPE)
 	DECL_NAME (type_decl) = classtype_mangled_name (t);
-      DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl);
       if (!is_partial_instantiation)
 	{
-	  DECL_ASSEMBLER_NAME (type_decl) = mangle_decl (type_decl);
-
 	  /* For backwards compatibility; code that uses
 	     -fexternal-templates expects looking up a template to
 	     instantiate it.  I think DDD still relies on this.
@@ -4606,18 +4584,14 @@ tsubst_friend_function (decl, args)
 	= DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
     }
 
-  /* The mangled name for the NEW_FRIEND is incorrect.  The call to
-     tsubst will have resulted in a call to
-     set_mangled_name_for_template_decl.  But, the function is not a
-     template instantiation and should not be mangled like one.
-     Therefore, we remangle the function name.  We don't have to do
-     this if the NEW_FRIEND is a template since
-     set_mangled_name_for_template_decl doesn't do anything if the
-     function declaration still uses template arguments.  */
+  /* The mangled name for the NEW_FRIEND is incorrect.  The function
+     is not a template instantiation and should not be mangled like
+     one.  Therefore, we forget the mangling here; we'll recompute it
+     later if we need it.  */
   if (TREE_CODE (new_friend) != TEMPLATE_DECL)
     {
-      set_mangled_name_for_decl (new_friend);
       SET_DECL_RTL (new_friend, NULL_RTX);
+      SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
     }
       
   if (DECL_NAMESPACE_SCOPE_P (new_friend))
@@ -5805,6 +5779,9 @@ tsubst_decl (t, args, type)
 	r = copy_decl (t);
 	DECL_USE_TEMPLATE (r) = 0;
 	TREE_TYPE (r) = type;
+	/* Clear out the mangled name and RTL for the instantiation.  */
+	SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
+	SET_DECL_RTL (r, NULL_RTX);
 
 	DECL_CONTEXT (r) = ctx;
 	DECL_VIRTUAL_CONTEXT (r)
@@ -5839,9 +5816,9 @@ tsubst_decl (t, args, type)
 	    TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
 	  }
 
-	/* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
-	   name.  There's no need to do this in the special friend
-	   case mentioned above where GEN_TMPL is NULL.  */
+	/* Set up the DECL_TEMPLATE_INFO for R.  There's no need to do
+	   this in the special friend case mentioned above where
+	   GEN_TMPL is NULL.  */
 	if (gen_tmpl)
 	  {
 	    DECL_TEMPLATE_INFO (r) 
@@ -5849,37 +5826,6 @@ tsubst_decl (t, args, type)
 	    SET_DECL_IMPLICIT_INSTANTIATION (r);
 	    register_specialization (r, gen_tmpl, argvec);
 
-	    /* Set the mangled name for R.  */
-	    if (DECL_DESTRUCTOR_P (t)) 
-	      set_mangled_name_for_decl (r);
-	    else 
-	      {
-		/* Instantiations of template functions must be mangled
-		   specially, in order to conform to 14.5.5.1
-		   [temp.over.link].  */
-		tree tmpl = DECL_TI_TEMPLATE (t);
-		
-		/* TMPL will be NULL if this is a specialization of a
-		   member function of a template class.  */
-		if (tmpl == NULL_TREE
-		    || (member && !is_member_template (tmpl)
-			&& !DECL_TEMPLATE_INFO (tmpl)))
-		  set_mangled_name_for_decl (r);
-		else
-		  set_mangled_name_for_template_decl (r);
-	      }
-	    
-	    SET_DECL_RTL (r, NULL_RTX);
-	    
-	    /* Like grokfndecl.  If we don't do this, pushdecl will
-	       mess up our TREE_CHAIN because it doesn't find a
-	       previous decl.  Sigh.  */
-	    if (member
-		&& ! uses_template_parms (r)
-		&& (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r)) 
-		    == NULL_TREE))
-	      SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r), r);
-
 	    /* We're not supposed to instantiate default arguments
 	       until they are called, for a template.  But, for a
 	       declaration like:
@@ -6032,6 +5978,9 @@ tsubst_decl (t, args, type)
 	TREE_TYPE (r) = type;
 	c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
 	DECL_CONTEXT (r) = ctx;
+	/* Clear out the mangled name and RTL for the instantiation.  */
+	SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
+	SET_DECL_RTL (r, NULL_RTX);
 
 	/* Don't try to expand the initializer until someone tries to use
 	   this variable; otherwise we run into circular dependencies.  */
@@ -9762,7 +9711,7 @@ regenerate_decl_from_template (decl, tmpl)
      functions, this is not so.  See tsubst_friend_function for
      details.  */
   DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl);
-  DECL_ASSEMBLER_NAME (new_decl) = DECL_ASSEMBLER_NAME (decl);
+  COPY_DECL_ASSEMBLER_NAME (decl, new_decl);
   COPY_DECL_RTL (decl, new_decl);
   DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl);
 
@@ -10292,21 +10241,6 @@ get_mostly_instantiated_function_type (decl, contextp, tparmsp)
   return fn_type;
 }
 
-/* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
-   is either an instantiation or specialization of a template
-   function.  */
-
-static void
-set_mangled_name_for_template_decl (decl)
-     tree decl;
-{
-  my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0);
-  my_friendly_assert (DECL_TEMPLATE_INFO (decl) != NULL_TREE, 0);
-
-  /* Under the new ABI, we don't need special machinery.  */
-  set_mangled_name_for_decl (decl);
-}
-
 /* Return truthvalue if we're processing a template different from
    the last one involved in diagnostics.  */
 int
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index 315f23d..49fc1ba 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -354,7 +354,7 @@ get_tinfo_decl (type)
       TREE_PUBLIC (d) = 1;
       if (flag_weak || !typeinfo_in_lib_p (d))
 	comdat_linkage (d);
-      DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
+      SET_DECL_ASSEMBLER_NAME (d, name);
       cp_finish_decl (d, NULL_TREE, NULL_TREE, 0);
 
       pushdecl_top_level (d);
@@ -837,8 +837,8 @@ tinfo_base_init (desc, target)
     comdat_linkage (name_decl);
     /* The new ABI specifies the external name of the string
        containing the type's name.  */
-    DECL_ASSEMBLER_NAME (name_decl) 
-      = mangle_typeinfo_string_for_type (target);
+    SET_DECL_ASSEMBLER_NAME (name_decl,
+			     mangle_typeinfo_string_for_type (target));
     DECL_INITIAL (name_decl) = name_string;
     cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
     pushdecl_top_level (name_decl);
@@ -1243,7 +1243,7 @@ create_real_tinfo_var (target_type, name, type, init, non_public)
       if (flag_weak || !typeinfo_in_lib_p (target_type))
 	comdat_linkage (decl);
     }
-  DECL_ASSEMBLER_NAME (decl) = name;
+  SET_DECL_ASSEMBLER_NAME (decl, name);
   DECL_INITIAL (decl) = init;
   cp_finish_decl (decl, init, NULL_TREE, 0);
   pushdecl_top_level (decl);
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 6b13469..95ede8b 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -649,8 +649,8 @@ lookup_field_1 (type, name)
 	;
       else if (DECL_NAME (field) == name)
 	{
-	  if ((TREE_CODE(field) == VAR_DECL || TREE_CODE(field) == CONST_DECL)
-	      && DECL_ASSEMBLER_NAME (field) != NULL)
+	  if (TREE_CODE(field) == VAR_DECL 
+	      && (TREE_STATIC (field) || DECL_EXTERNAL (field)))
 	    GNU_xref_ref(current_function_decl,
 			 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (field)));
 	  return field;
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 97f0103..dec0e8d 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1033,10 +1033,7 @@ finish_named_return_value (return_id, init)
   if (return_id != NULL_TREE)
     {
       if (DECL_NAME (decl) == NULL_TREE)
-	{
-	  DECL_NAME (decl) = return_id;
-	  DECL_ASSEMBLER_NAME (decl) = return_id;
-	}
+	DECL_NAME (decl) = return_id;
       else
 	{
 	  cp_error ("return identifier `%D' already in place", return_id);
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 6a3de30..93e12be 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -2319,6 +2319,7 @@ init_tree ()
   make_lang_type_fn = cp_make_lang_type;
   lang_unsave = cp_unsave;
   lang_statement_code_p = cp_statement_code_p;
+  lang_set_decl_assembler_name = mangle_decl;
   list_hash_table = htab_create (31, list_hash, list_hash_eq, NULL);
   ggc_add_root (&list_hash_table, 1, 
 		sizeof (list_hash_table),
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index 73be0b0..fd9fc0c 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -833,10 +833,18 @@ dbxout_type_methods (type)
 	{
 	  /* This is the "mangled" name of the method.
 	     It encodes the argument types.  */
-	  const char *debug_name =
-	    IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
+	  const char *debug_name;
 	  int show_arg_types = 0;
 
+	  /* Skip methods that aren't FUNCTION_DECLs.  (In C++, these
+	     include TEMPLATE_DECLs.)  The debugger doesn't know what
+	     to do with such entities anyhow.  */
+	  if (TREE_CODE (fndecl) != FUNCTION_DECL)
+	    continue;
+
+	  debug_name =
+	    IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
+
 	  CONTIN;
 
 	  last = fndecl;
diff --git a/gcc/f/ChangeLog b/gcc/f/ChangeLog
index b275476..78fc680 100644
--- a/gcc/f/ChangeLog
+++ b/gcc/f/ChangeLog
@@ -1,3 +1,7 @@
+Mon Mar 19 15:05:39 2001  Mark Mitchell  <mark@codesourcery.com>
+
+	* com.c (builtin_function): Use SET_DECL_ASSEMBLER_NAME.
+
 Wed Mar 14 09:29:27 2001  Mark Mitchell  <mark@codesourcery.com>
 
 	* com.c (ffecom_member_phase_2): Use COPY_DECL_RTL,
diff --git a/gcc/f/com.c b/gcc/f/com.c
index fda6ce3..bce0bbb 100644
--- a/gcc/f/com.c
+++ b/gcc/f/com.c
@@ -13497,7 +13497,7 @@ builtin_function (const char *name, tree type, int function_code,
   DECL_EXTERNAL (decl) = 1;
   TREE_PUBLIC (decl) = 1;
   if (library_name)
-    DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+    SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
   make_decl_rtl (decl, NULL_PTR);
   pushdecl (decl);
   DECL_BUILT_IN_CLASS (decl) = class;
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index ffbbe20..b82eb5b 100644
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -373,13 +373,14 @@ ggc_mark_trees ()
 	  ggc_mark_tree (DECL_RESULT_FLD (t));
 	  ggc_mark_tree (DECL_INITIAL (t));
 	  ggc_mark_tree (DECL_ABSTRACT_ORIGIN (t));
-	  ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
 	  ggc_mark_tree (DECL_SECTION_NAME (t));
 	  ggc_mark_tree (DECL_MACHINE_ATTRIBUTES (t));
 	  if (DECL_RTL_SET_P (t))
 	    ggc_mark_rtx (DECL_RTL (t));
 	  ggc_mark_rtx (DECL_LIVE_RANGE_RTL (t));
 	  ggc_mark_tree (DECL_VINDEX (t));
+	  if (DECL_ASSEMBLER_NAME_SET_P (t))
+	    ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
 	  lang_mark_tree (t);
 	  break;
 
diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 2a96eb5..3d1f6e4c 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,12 @@
+2001-03-19  Mark Mitchell  <mark@codesourcery.com>
+
+	* class.c (build_class_ref): Use SET_DECL_ASSEMBLER_NAME.
+	(layout_class): Likewise.
+	(layout_class_method): Likewise.
+	(emit_register_classes): Likewise.
+	* decl.c (builtin_function): Likewise.
+	(give_name_to_locals): Likewise.
+
 2001-03-19  Per Bothner  <per@bothner.com>
 
 	* jcf-parse.c (load_inner_classes):  Check CLASS_LOADED_P
diff --git a/gcc/java/class.c b/gcc/java/class.c
index 4114271..6deb46e 100644
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -899,8 +899,9 @@ build_class_ref (type)
 	      TREE_PUBLIC (decl) = 1;
 	      DECL_IGNORED_P (decl) = 1;
 	      DECL_ARTIFICIAL (decl) = 1;
-	      DECL_ASSEMBLER_NAME (decl) = 
-		java_mangle_class_field (&temporary_obstack, type);
+	      SET_DECL_ASSEMBLER_NAME (decl, 
+				       java_mangle_class_field
+				       (&temporary_obstack, type));
 	      make_decl_rtl (decl, NULL);
 	      pushdecl_top_level (decl);
 	      if (is_compiled == 1)
@@ -1701,8 +1702,9 @@ layout_class (this_class)
       if (FIELD_STATIC (field))
 	{
 	  /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
-	  DECL_ASSEMBLER_NAME (field) = 
-	    java_mangle_decl (&temporary_obstack, field);
+	  SET_DECL_ASSEMBLER_NAME (field,
+				   java_mangle_decl
+				   (&temporary_obstack, field));
 	}
     }
 
@@ -1797,8 +1799,9 @@ layout_class_method (this_class, super_class, method_decl, dtable_count)
   TREE_PUBLIC (method_decl) = 1;
 
   /* This is a good occasion to mangle the method's name */
-  DECL_ASSEMBLER_NAME (method_decl) = 
-    java_mangle_decl (&temporary_obstack, method_decl);
+  SET_DECL_ASSEMBLER_NAME (method_decl,
+			   java_mangle_decl (&temporary_obstack, 
+					     method_decl));
   /* We don't generate a RTL for the method if it's abstract, or if
      it's an interface method that isn't clinit. */
   if (! METHOD_ABSTRACT (method_decl) 
@@ -1878,7 +1881,7 @@ emit_register_classes ()
   tree t;
 
   init_decl = build_decl (FUNCTION_DECL, init_name, init_type);
-  DECL_ASSEMBLER_NAME (init_decl) = init_name;
+  SET_DECL_ASSEMBLER_NAME (init_decl, init_name);
   TREE_STATIC (init_decl) = 1;
   current_function_decl = init_decl;
   DECL_RESULT (init_decl) = build_decl(RESULT_DECL, NULL_TREE, void_type_node);
diff --git a/gcc/java/decl.c b/gcc/java/decl.c
index 8c688ce..1a68a04 100644
--- a/gcc/java/decl.c
+++ b/gcc/java/decl.c
@@ -377,7 +377,7 @@ builtin_function (name, type, function_code, class, library_name)
   DECL_EXTERNAL (decl) = 1;
   TREE_PUBLIC (decl) = 1;
   if (library_name)
-    DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+    SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
   make_decl_rtl (decl, NULL_PTR);
   pushdecl (decl);
   DECL_BUILT_IN_CLASS (decl) = class;
@@ -1569,7 +1569,7 @@ give_name_to_locals (jcf)
 	{
 	  tree decl = TREE_VEC_ELT (decl_map, slot);
 	  DECL_NAME (decl) = name;
-	  DECL_ASSEMBLER_NAME (decl) = name;
+	  SET_DECL_ASSEMBLER_NAME (decl, name);
 	  if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
 	    warning ("bad type in parameter debug info");
 	}
@@ -1636,7 +1636,7 @@ give_name_to_locals (jcf)
 	      sprintf (buffer, "ARG_%d", arg_i);
 	      DECL_NAME (parm) = get_identifier (buffer);
 	    }
-	  DECL_ASSEMBLER_NAME (parm) = DECL_NAME (parm);
+	  SET_DECL_ASSEMBLER_NAME (parm, DECL_NAME (parm));
 	}
     }
 }
diff --git a/gcc/profile.c b/gcc/profile.c
index 3cdd34b..55eab8b 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -1108,7 +1108,6 @@ output_func_start_profiler ()
   TREE_PUBLIC (fndecl) = 1;
 #endif
 
-  DECL_ASSEMBLER_NAME (fndecl) = fnname;
   DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
 
   fndecl = pushdecl (fndecl);
diff --git a/gcc/testsuite/g++.old-deja/g++.other/mangle1.C b/gcc/testsuite/g++.old-deja/g++.other/mangle1.C
deleted file mode 100644
index b4f7245..0000000
--- a/gcc/testsuite/g++.old-deja/g++.other/mangle1.C
+++ /dev/null
@@ -1,57 +0,0 @@
-// Test for proper mangling by setting up name clashes.
-
-#if (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100)
-#define NAME(OLD, NEW) OLD
-#else
-#define NAME(OLD, NEW) NEW
-#endif /* (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100) */
-
-class A { };
-typedef A A2;
-typedef int I;
-typedef void V;
-typedef I I2;
-
-void f (const A2&, int, const A2&, const A&) { } // ERROR - name clash
-int NAME (f__FRC1AiT0T0, _Z1fRK1AiS1_S1_) = 0; // ERROR - name clash
-
-void f (int, long, int, I) { } // ERROR - name clash
-int NAME (f__Filii, _Z1filii) = 0; // ERROR - name clash
-
-void f (I, float, I, I2) { } // ERROR - name clash
-int NAME (f__Fifii, _Z1fifii) = 0; // ERROR - name clash
-
-void f (void*, float, void*, V*) { } // ERROR - name clash
-int NAME (f__FPvfT0T0, _Z1fPvfS_S_) = 0; // ERROR - name clash
-
-void f (wchar_t) { } // ERROR - name clash
-int NAME (f__Fw, _Z1fw) = 0; // ERROR - name clash
-
-void f(int, A, A2, A) { } // ERROR - name clash
-int NAME (f__FiG1AN21, _Z1fi1AS_S_) = 0; // ERROR - name clash
-
-void f(const A2&, const A2&, const A2&, const A2&,
-       int&) { } // ERROR - name clash
-int NAME (f__FRC1AN30Ri, _Z1fRK1AS1_S1_S1_Ri) = 0; // ERROR - name clash
-
-void f(const A2&, int, const A2&, const A2&, const A2&,
-       int&) { } // ERROR - name clash
-int NAME (f__FRC1AiT0N20Ri, _Z1fRK1AiS1_S1_S1_Ri) = 0; // ERROR - name clash
-
-void f(const A2&, int, const A2&, const A2&, const A2&, int&, int&,
-       int&) { } // ERROR - name clash
-int NAME (f__FRC1AiT0N20RiN25, _Z1fRK1AiS1_S1_S1_RiS2_S2_) = 0; // ERROR - name clash
-
-void f(const A2&, int, const A2&, const A2&, const A2&, int, int,
-       int) { } // ERROR - name clash
-int NAME (f__FRC1AiT0N20iii, _Z1fRK1AiS1_S1_S1_iii) = 0; // ERROR - name clash
-
-void f(bool, bool) {} // ERROR - name clash
-int NAME (f__FbT0, _Z1fbb) = 0; // ERROR - name clash
-
-int
-main ()
-{
-  return 0;
-}
-
diff --git a/gcc/testsuite/g++.old-deja/g++.other/mangle2.C b/gcc/testsuite/g++.old-deja/g++.other/mangle2.C
deleted file mode 100644
index 25bab87..0000000
--- a/gcc/testsuite/g++.old-deja/g++.other/mangle2.C
+++ /dev/null
@@ -1,24 +0,0 @@
-// Test for overloaded operators in "C" linkage
-// Build don't link:
-
-extern "C" {
-typedef struct b
-{
-  int a;
-} c;
-
-extern const c z;
-
-inline bool operator!=(const c& x, const c& y)
-{
-  return x.a != y.a;
-}
-};
-
-void foo();
-
-void bar(c x)
-{
-  if (x != z)
-    foo();
-}
diff --git a/gcc/testsuite/g++.old-deja/g++.other/static8.C b/gcc/testsuite/g++.old-deja/g++.other/static8.C
deleted file mode 100644
index 4cd89ca..0000000
--- a/gcc/testsuite/g++.old-deja/g++.other/static8.C
+++ /dev/null
@@ -1,12 +0,0 @@
-// Build don't link:
-// Origin: Mark Mitchell <mark@codesourcery.com>
-
-#if (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100)
-#define NAME(OLD, NEW) OLD
-#else
-#define NAME(OLD, NEW) NEW
-#endif /* (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100) */
-
-static unsigned int strlen (const char*) {return 0;} // ERROR - previous declaration
-
-int NAME (strlen__FPCc, _Z6strlenPKc) = 0; // ERROR - duplicate declaration
diff --git a/gcc/tree.c b/gcc/tree.c
index 3143db4..573d7a2 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -182,10 +182,42 @@ void (*lang_unsave_expr_now) PARAMS ((tree));
 /* If non-null, these are language-specific helper functions for
    unsafe_for_reeval.  Return negative to not handle some tree.  */
 int (*lang_unsafe_for_reeval) PARAMS ((tree));
+
+/* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of thing
+   that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
+   appropriate IDENTIFIER_NODE.  Otherwise, set it to the
+   ERROR_MARK_NODE to ensure that the assembler does not talk about
+   it.  */
+void (*lang_set_decl_assembler_name)     PARAMS ((tree));
 
 tree global_trees[TI_MAX];
 tree integer_types[itk_none];
 
+/* Set the DECL_ASSEMBLER_NAME for DECL.  */
+void
+set_decl_assembler_name (decl)
+     tree decl;
+{
+  /* The language-independent code should never use the
+     DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
+     VAR_DECLs for variables with static storage duration need a real
+     DECL_ASSEMBLER_NAME.  */
+  if (TREE_CODE (decl) == FUNCTION_DECL
+      || (TREE_CODE (decl) == VAR_DECL 
+	  && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))))
+    /* By default, assume the name to use in assembly code is the
+       same as that used in the source language.  (That's correct
+       for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
+       value as DECL_NAME in build_decl, so this choice provides
+       backwards compatibility with existing front-ends.  */
+    SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+  else
+    /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
+       these DECLs -- unless they're in language-dependent code, in
+       which case lang_set_decl_assembler_name should handle things.  */
+    abort ();
+}
+
 /* Init the principal obstacks.  */
 
 void
@@ -199,6 +231,9 @@ init_obstacks ()
   ggc_add_root (&type_hash_table, 1, sizeof type_hash_table, mark_type_hash);
   ggc_add_tree_root (global_trees, TI_MAX);
   ggc_add_tree_root (integer_types, itk_none);
+
+  /* Set lang_set_decl_set_assembler_name to a default value.  */
+  lang_set_decl_assembler_name = set_decl_assembler_name;
 }
 
 void
@@ -2557,7 +2592,6 @@ build_decl (code, name, type)
    as the type can suppress useless errors in the use of this variable.  */
 
   DECL_NAME (t) = name;
-  DECL_ASSEMBLER_NAME (t) = name;
   TREE_TYPE (t) = type;
 
   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
diff --git a/gcc/tree.h b/gcc/tree.h
index 55e19c0..e7a2df1 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1255,11 +1255,37 @@ struct tree_type
 /* This is the name of the object as written by the user.
    It is an IDENTIFIER_NODE.  */
 #define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name)
-/* This is the name of the object as the assembler will see it
-   (but before any translations made by ASM_OUTPUT_LABELREF).
-   Often this is the same as DECL_NAME.
-   It is an IDENTIFIER_NODE.  */
-#define DECL_ASSEMBLER_NAME(NODE) (DECL_CHECK (NODE)->decl.assembler_name)
+/* The name of the object as the assembler will see it (but before any
+   translations made by ASM_OUTPUT_LABELREF).  Often this is the same
+   as DECL_NAME.  It is an IDENTIFIER_NODE.  */
+#define DECL_ASSEMBLER_NAME(NODE)		\
+  ((DECL_ASSEMBLER_NAME_SET_P (NODE)		\
+    ? (void) 0					\
+    : (*lang_set_decl_assembler_name) (NODE)),	\
+   DECL_CHECK (NODE)->decl.assembler_name)
+/* Returns non-zero if the DECL_ASSEMBLER_NAME for NODE has been 
+   set.  If zero, the NODE might still have a DECL_ASSEMBLER_NAME --
+   it just hasn't been set yet.  */
+#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
+  (DECL_CHECK (NODE)->decl.assembler_name != NULL_TREE)
+/* Set the DECL_ASSEMBLER_NAME for NODE to NAME.  */
+#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
+  (DECL_CHECK (NODE)->decl.assembler_name = (NAME))
+/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2.  Note that if
+   DECL1's DECL_ASSEMBLER_NAME has not yet been set, using this macro
+   will not cause the DECL_ASSEMBLER_NAME of either DECL to be set.
+   In other words, the semantics of using this macro, are different
+   than saying:
+     
+     SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
+
+   which will try to set the DECL_ASSEMBLER_NAME for DECL1.  */
+#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2)				\
+  (DECL_ASSEMBLER_NAME_SET_P (DECL1)					\
+   ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, 				\
+                                     DECL_ASSEMBLER_NAME (DECL1))	\
+   : (void) 0)
+
 /* Records the section name in a section attribute.  Used to pass
    the name from decl_attributes to make_function_rtl and make_decl_rtl.  */
 #define DECL_SECTION_NAME(NODE) (DECL_CHECK (NODE)->decl.section_name)
@@ -2497,6 +2523,7 @@ extern tree get_set_constructor_bits		PARAMS ((tree, char *, int));
 extern tree get_set_constructor_bytes		PARAMS ((tree,
 						       unsigned char *, int));
 extern tree get_callee_fndecl                   PARAMS ((tree));
+extern void set_decl_assembler_name             PARAMS ((tree));
 
 /* In stmt.c */
 
@@ -2666,6 +2693,13 @@ extern int objects_must_conflict_p		PARAMS ((tree, tree));
 /* In c-common.c */
 extern HOST_WIDE_INT lang_get_alias_set		PARAMS ((tree));
 
+/* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of thing
+   that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
+   appropriate IDENTIFIER_NODE.  Otherwise, set it to the
+   ERROR_MARK_NODE to ensure that the assembler does not talk about
+   it.  */
+extern void (*lang_set_decl_assembler_name)     PARAMS ((tree));
+
 struct obstack;
 
 /* In tree.c */
diff --git a/gcc/varasm.c b/gcc/varasm.c
index b9cc6df..380df02 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -738,7 +738,7 @@ make_decl_rtl (decl, asmspec)
 
   if (name != new_name)
     {
-      DECL_ASSEMBLER_NAME (decl) = get_identifier (new_name);
+      SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
     }