dwarf2out.c (output_call_frame_info): Set SYMBOL_FLAG_LOCAL on generated SYMBOL_REFs for labels.

	* dwarf2out.c (output_call_frame_info): Set SYMBOL_FLAG_LOCAL on
	generated SYMBOL_REFs for labels.
	* config/darwin-protos.h (machopic_validate_stub_or_non_lazy_ptr):
	Change prototype.
	(machopic_stub_name): Remove.
	(machopic_indirection_name): New function.
	(machopic_mcount_stub_name): Likewise.
	(machopic_classify_name): Remove.
	(machopic_function_base_sym): New function.
	(machpoic_classify_symbol): Likewise.
	(machopic_classify_ident): Remove.
	(machopic_define_ident): Likewise.
	(machopic_define_name): Likewise.
	(machopic_name_defined_p): Likewise.
	(machopic_ident_defined_p): Likewise.
	(darwin_strip_name_encoding): Likewise.
	(machopic_define_symbol): New function.
	* config/darwin.c (hashtab.h): Include.
	(machopic_defined_list): Remove.
	(machopic_classify_ident): Likewise.
	(machopic_classify_name): Likewise.
	(machopic_ident_defined_p): Likewise.
	(machopic_define_ident): Likewise.
	(machopic_define_name): Likewise.
	(machopic_symbol_defined_p): New function.
	(machopic_classify_symbol): Likewise.
	(machopic_data_defined_p): Use machopic_classify_symbol.
	(machopic_define_symbol): New function.
	(machopic_function_base_sym): New function.
	(machopic_non_lazy_pointers): Remove.
	(machopic_non_lazy_ptr_name): Likewise.
	(machopic_stubs): Likewise.
	(machopic_stub_name): Likewise.
	(NON_LAZY_POINTER_SUFFIX): New macro.
	(STUB_SUFFIX): Likewise.
	(machopic_indirection): New structure.
	(machopic_indirections): New variable.
	(machopic_indirection_hash): New function.
	(machopic_indirection_eq): Likewise.
	(machopic_indirection_name): Likewise.
	(machopic_mcount_stub_name): New function.
	(machopic_validate_stub_or_non_lazy_pointer): Reimplement to use
	hash table.
	(machopic_indirect_data_reference): Rework to use new functions.
	(machopic_indirect_call_target): Likewise.
	(machopic_legitimize_pic_address): Likewise.
	(machopic_output_indirection): New function.
	(machopic_finish): Use it.
	(machopic_operand_p): Rework to use new functions.
	(darwin_encode_seciton_info): Use SYMBOL_REF_FLAGS.
	(darwin_strip_name_encoding): Remove.
	(update_non_lazy_ptrs): Remove.
	(update_stubs): Likewise.
	(darwin_non_lazy_pcrel): Use new functions.
	* config/darwin.h (ASM_DECLARE_OBJECT_NAME): Likewise.
	(ASM_OUTPUT_LABELREF): Likewise.
	(ASM_OUTPUT_ALIGNED_DECL_LOCAL): Likewise.
	(MACHO_SYMBOL_FLAG_VARIABLE): New macro.
	(MACHO_SYMBOL_FLAG_DEFINED): Likewise.
	(TARGET_STRIP_NAME_ENCODING): Do not use
	darwin_strip_name_encoding.
	(GEN_LAZY_PTR_NAME_FOR_SYMBOL): Do not use
	darwin_strip_name_encoding.
	* config/i386/darwin.h (FUNCTION_PROFILER): Use
	machopic_mcount_stub_name.
	* config/i386/i386.c (x86_output_mi_thunk): Use
	machopic_indirection_name, not machopic_stub_name.
	* config/rs6000/rs6000.c (rs6000_legitimize_reload_address): Use
	machopic_function_base_sym.
	(print_operand): Use machopic_classify_symbol.
	(rs6000_emit_prologue): Use machopic_function_base_sym.
	(output_profile_hook): Do not use machopic_stub_name.
	(macho_branch_isalnds): Do not use darwin_strip_name_encoding.

From-SVN: r85071

8 files changed, 379 insertions, 541 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 43770e9..7e08c39 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,79 @@
+2004-07-22  Mark Mitchell  <mark@codesourcery.com>
+
+	* dwarf2out.c (output_call_frame_info): Set SYMBOL_FLAG_LOCAL on
+	generated SYMBOL_REFs for labels.
+	* config/darwin-protos.h (machopic_validate_stub_or_non_lazy_ptr):
+	Change prototype.
+	(machopic_stub_name): Remove.
+	(machopic_indirection_name): New function.
+	(machopic_mcount_stub_name): Likewise.
+	(machopic_classify_name): Remove.
+	(machopic_function_base_sym): New function.
+	(machpoic_classify_symbol): Likewise.
+	(machopic_classify_ident): Remove.
+	(machopic_define_ident): Likewise.
+	(machopic_define_name): Likewise.
+	(machopic_name_defined_p): Likewise.
+	(machopic_ident_defined_p): Likewise.
+	(darwin_strip_name_encoding): Likewise.
+	(machopic_define_symbol): New function.
+	* config/darwin.c (hashtab.h): Include.
+	(machopic_defined_list): Remove.
+	(machopic_classify_ident): Likewise.
+	(machopic_classify_name): Likewise.
+	(machopic_ident_defined_p): Likewise.
+	(machopic_define_ident): Likewise.
+	(machopic_define_name): Likewise.
+	(machopic_symbol_defined_p): New function.
+	(machopic_classify_symbol): Likewise.
+	(machopic_data_defined_p): Use machopic_classify_symbol.
+	(machopic_define_symbol): New function.
+	(machopic_function_base_sym): New function.
+	(machopic_non_lazy_pointers): Remove.
+	(machopic_non_lazy_ptr_name): Likewise.
+	(machopic_stubs): Likewise.
+	(machopic_stub_name): Likewise.
+	(NON_LAZY_POINTER_SUFFIX): New macro.
+	(STUB_SUFFIX): Likewise.
+	(machopic_indirection): New structure.
+	(machopic_indirections): New variable.
+	(machopic_indirection_hash): New function.
+	(machopic_indirection_eq): Likewise.
+	(machopic_indirection_name): Likewise.
+	(machopic_mcount_stub_name): New function.
+	(machopic_validate_stub_or_non_lazy_pointer): Reimplement to use
+	hash table.
+	(machopic_indirect_data_reference): Rework to use new functions.
+	(machopic_indirect_call_target): Likewise.
+	(machopic_legitimize_pic_address): Likewise.
+	(machopic_output_indirection): New function.
+	(machopic_finish): Use it.
+	(machopic_operand_p): Rework to use new functions.
+	(darwin_encode_seciton_info): Use SYMBOL_REF_FLAGS.
+	(darwin_strip_name_encoding): Remove.
+	(update_non_lazy_ptrs): Remove.
+	(update_stubs): Likewise.
+	(darwin_non_lazy_pcrel): Use new functions.
+	* config/darwin.h (ASM_DECLARE_OBJECT_NAME): Likewise.
+	(ASM_OUTPUT_LABELREF): Likewise.
+	(ASM_OUTPUT_ALIGNED_DECL_LOCAL): Likewise.
+	(MACHO_SYMBOL_FLAG_VARIABLE): New macro.
+	(MACHO_SYMBOL_FLAG_DEFINED): Likewise.
+	(TARGET_STRIP_NAME_ENCODING): Do not use
+	darwin_strip_name_encoding.
+	(GEN_LAZY_PTR_NAME_FOR_SYMBOL): Do not use
+	darwin_strip_name_encoding.
+	* config/i386/darwin.h (FUNCTION_PROFILER): Use
+	machopic_mcount_stub_name.
+	* config/i386/i386.c (x86_output_mi_thunk): Use
+	machopic_indirection_name, not machopic_stub_name.
+	* config/rs6000/rs6000.c (rs6000_legitimize_reload_address): Use
+	machopic_function_base_sym.
+	(print_operand): Use machopic_classify_symbol.
+	(rs6000_emit_prologue): Use machopic_function_base_sym.
+	(output_profile_hook): Do not use machopic_stub_name.
+	(macho_branch_isalnds): Do not use darwin_strip_name_encoding.
+	
 2004-07-22  Joseph S. Myers  <jsm@polyomino.org.uk>
 
 	PR c/7284
diff --git a/gcc/config/darwin-protos.h b/gcc/config/darwin-protos.h
index 1cfdd73..d2d9004 100644
--- a/gcc/config/darwin-protos.h
+++ b/gcc/config/darwin-protos.h
@@ -20,11 +20,12 @@ Boston, MA 02111-1307, USA.  */
 
 extern int name_needs_quotes (const char *);
 
-extern void machopic_validate_stub_or_non_lazy_ptr (const char *, int);
+extern void machopic_validate_stub_or_non_lazy_ptr (const char *);
 
 extern const char *machopic_function_base_name (void);
 extern void machopic_output_function_base_name (FILE *);
-extern const char *machopic_stub_name (const char*);
+extern const char *machopic_indirection_name (rtx, bool);
+extern const char *machopic_mcount_stub_name (void);
 
 extern void machopic_picsymbol_stub_section (void);
 extern void machopic_picsymbol_stub1_section (void);
@@ -40,8 +41,9 @@ extern void mod_term_section (void);
 
 #ifdef RTX_CODE
 
+extern rtx machopic_function_base_sym (void);
 extern int machopic_operand_p (rtx);
-extern enum machopic_addr_class machopic_classify_name (const char*);
+extern enum machopic_addr_class machopic_classify_symbol (rtx);
 
 extern rtx machopic_indirect_data_reference (rtx, rtx);
 extern rtx machopic_indirect_call_target (rtx);
@@ -53,13 +55,8 @@ extern void machopic_asm_out_destructor (rtx, int);
 
 #ifdef TREE_CODE
 
-extern enum machopic_addr_class machopic_classify_ident (tree);
-extern void machopic_define_ident (tree);
-extern void machopic_define_name (const char*);
-extern int machopic_name_defined_p (const char*);
-extern int machopic_ident_defined_p (tree);
+extern void machopic_define_symbol (rtx);
 extern void darwin_encode_section_info (tree, rtx, int);
-extern const char *darwin_strip_name_encoding (const char *);
 
 #endif /* TREE_CODE */
 
diff --git a/gcc/config/darwin.c b/gcc/config/darwin.c
index e46690c..e3bf3a2 100644
--- a/gcc/config/darwin.c
+++ b/gcc/config/darwin.c
@@ -42,11 +42,7 @@ Boston, MA 02111-1307, USA.  */
 #include "langhooks.h"
 #include "tm_p.h"
 #include "errors.h"
-
-static int machopic_data_defined_p (const char *);
-static void update_non_lazy_ptrs (const char *);
-static void update_stubs (const char *);
-static const char *machopic_non_lazy_ptr_name (const char*);
+#include "hashtab.h"
 
 int
 name_needs_quotes (const char *name)
@@ -63,131 +59,37 @@ name_needs_quotes (const char *name)
  * flag_pic = 2 ... generate indirections and pure code
  */
 
-/* This module assumes that (const (symbol_ref "foo")) is a legal pic
-   reference, which will not be changed.  */
-
-static GTY(()) tree machopic_defined_list;
-
-enum machopic_addr_class
-machopic_classify_ident (tree ident)
+static int
+machopic_symbol_defined_p (rtx sym_ref)
 {
-  const char *name = IDENTIFIER_POINTER (ident);
-  int lprefix = (((name[0] == '*' || name[0] == '&')
-		  && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
-		 || (   name[0] == '_'
-		     && name[1] == 'O'
-		     && name[2] == 'B'
-		     && name[3] == 'J'
-		     && name[4] == 'C'
-		     && name[5] == '_'));
-  tree temp;
-
-  /* The PIC base symbol is always defined.  */
-  if (! strcmp (name, "<pic base>"))
-    return MACHOPIC_DEFINED_DATA;
-
-  if (name[0] != '!')
-    {
-      /* Here if no special encoding to be found.  */
-      if (lprefix)
-	{
-	  const char *name = IDENTIFIER_POINTER (ident);
-	  int len = strlen (name);
-
-	  if ((len > 5 && !strcmp (name + len - 5, "$stub"))
-	      || (len > 6 && !strcmp (name + len - 6, "$stub\"")))
-	    return MACHOPIC_DEFINED_FUNCTION;
-	  return MACHOPIC_DEFINED_DATA;
-	}
-
-      for (temp = machopic_defined_list;
-	   temp != NULL_TREE;
-	   temp = TREE_CHAIN (temp))
-	{
-	  if (ident == TREE_VALUE (temp))
-	    return MACHOPIC_DEFINED_DATA;
-	}
-
-      if (TREE_ASM_WRITTEN (ident))
-	return MACHOPIC_DEFINED_DATA;
-
-      return MACHOPIC_UNDEFINED;
-    }
-
-  else if (name[1] == 'D')
-    return MACHOPIC_DEFINED_DATA;
-
-  else if (name[1] == 'T')
-    return MACHOPIC_DEFINED_FUNCTION;
-
-  /* It is possible that someone is holding a "stale" name, which has
-     since been defined.  See if there is a "defined" name (i.e,
-     different from NAME only in having a '!D_' or a '!T_' instead of
-     a '!d_' or '!t_' prefix) in the identifier hash tables.  If so, say
-     that this identifier is defined.  */
-  else if (name[1] == 'd' || name[1] == 't')
-    {
-      char *new_name;
-      new_name = (char *)alloca (strlen (name) + 1);
-      strcpy (new_name, name);
-      new_name[1] = (name[1] == 'd') ? 'D' : 'T';
-      if (maybe_get_identifier (new_name) != NULL)
-	return  (name[1] == 'd') ? MACHOPIC_DEFINED_DATA
-				 : MACHOPIC_DEFINED_FUNCTION;
-    }
-
-  for (temp = machopic_defined_list; temp != NULL_TREE; temp = TREE_CHAIN (temp))
-    {
-      if (ident == TREE_VALUE (temp))
-	{
-	  if (name[1] == 'T')
-	    return MACHOPIC_DEFINED_FUNCTION;
-	  else
-	    return MACHOPIC_DEFINED_DATA;
-	}
-    }
-
-  if (name[1] == 't' || name[1] == 'T')
-    {
-      if (lprefix)
-	return MACHOPIC_DEFINED_FUNCTION;
-      else
-	return MACHOPIC_UNDEFINED_FUNCTION;
-    }
-  else
-    {
-      if (lprefix)
-	return MACHOPIC_DEFINED_DATA;
-      else
-	return MACHOPIC_UNDEFINED_DATA;
-    }
+  return ((SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
+	  /* Local symbols must always be defined.  */
+	  || SYMBOL_REF_LOCAL_P (sym_ref));
 }
 
+/* This module assumes that (const (symbol_ref "foo")) is a legal pic
+   reference, which will not be changed.  */
 
 enum machopic_addr_class
-machopic_classify_name (const char *name)
+machopic_classify_symbol (rtx sym_ref)
 {
-  return machopic_classify_ident (get_identifier (name));
-}
-
-int
-machopic_ident_defined_p (tree ident)
-{
-  switch (machopic_classify_ident (ident))
-    {
-    case MACHOPIC_UNDEFINED:
-    case MACHOPIC_UNDEFINED_DATA:
-    case MACHOPIC_UNDEFINED_FUNCTION:
-      return 0;
-    default:
-      return 1;
-    }
+  int flags;
+  bool function_p;
+
+  flags = SYMBOL_REF_FLAGS (sym_ref);
+  function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
+  if (machopic_symbol_defined_p (sym_ref))
+    return (function_p 
+	    ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
+  else
+    return (function_p 
+	    ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
 }
 
 static int
-machopic_data_defined_p (const char *name)
+machopic_data_defined_p (rtx sym_ref)
 {
-  switch (machopic_classify_ident (get_identifier (name)))
+  switch (machopic_classify_symbol (sym_ref))
     {
     case MACHOPIC_DEFINED_DATA:
       return 1;
@@ -196,24 +98,14 @@ machopic_data_defined_p (const char *name)
     }
 }
 
-int
-machopic_name_defined_p (const char *name)
-{
-  return machopic_ident_defined_p (get_identifier (name));
-}
-
-void
-machopic_define_ident (tree ident)
-{
-  if (!machopic_ident_defined_p (ident))
-    machopic_defined_list =
-      tree_cons (NULL_TREE, ident, machopic_defined_list);
-}
-
 void
-machopic_define_name (const char *name)
+machopic_define_symbol (rtx mem)
 {
-  machopic_define_ident (get_identifier (name));
+  rtx sym_ref;
+  if (GET_CODE (mem) != MEM)
+    abort ();
+  sym_ref = XEXP (mem, 0);
+  SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
 }
 
 static GTY(()) char * function_base;
@@ -234,6 +126,19 @@ machopic_function_base_name (void)
   return function_base;
 }
 
+/* Return a SYMBOL_REF for the PIC function base.  */
+
+rtx
+machopic_function_base_sym (void)
+{
+  rtx sym_ref;
+
+  sym_ref = gen_rtx_SYMBOL_REF (Pmode, machopic_function_base_name ());
+  SYMBOL_REF_FLAGS (sym_ref) 
+    |= (MACHO_SYMBOL_FLAG_VARIABLE | MACHO_SYMBOL_FLAG_DEFINED);
+  return sym_ref;
+}
+
 static GTY(()) const char * function_base_func_name;
 static GTY(()) int current_pic_label_num;
 
@@ -255,182 +160,155 @@ machopic_output_function_base_name (FILE *file)
   fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
 }
 
-static GTY(()) tree machopic_non_lazy_pointers;
-
-/* Return a non-lazy pointer name corresponding to the given name,
-   either by finding it in our list of pointer names, or by generating
-   a new one.  */
+/* The suffix attached to non-lazy pointer symbols.  */
+#define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
+/* The suffix attached to stub symbols.  */
+#define STUB_SUFFIX "$stub"
 
-static const char *
-machopic_non_lazy_ptr_name (const char *name)
+typedef struct machopic_indirection GTY (())
 {
-  const char *temp_name;
-  tree temp, ident = get_identifier (name);
+  /* The SYMBOL_REF for the entity referenced.  */
+  rtx symbol;
+  /* The IDENTIFIER_NODE giving the name of the stub or non-lazy
+     pointer.  */
+  tree ptr_name;
+  /* True iff this entry is for a stub (as opposed to a non-lazy
+     pointer).  */
+  bool stub_p;
+  /* True iff this stub or pointer pointer has been referenced.  */
+  bool used;
+} machopic_indirection;
+
+/* A table mapping stub names and non-lazy pointer names to
+   SYMBOL_REFs for the stubbed-to and pointed-to entities.  */
+
+static GTY ((param_is (struct machopic_indirection))) htab_t 
+  machopic_indirections;
+
+/* Return a hash value for a SLOT in the indirections hash table.  */
+
+static hashval_t
+machopic_indirection_hash (const void *slot)
+{
+  const machopic_indirection *p = (const machopic_indirection *) slot;
+  return IDENTIFIER_HASH_VALUE (p->ptr_name);
+}
 
-  for (temp = machopic_non_lazy_pointers;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
-    {
-      if (ident == TREE_VALUE (temp))
-	return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
-    }
+/* Returns true if the KEY is the same as that associated with
+   SLOT.  */
+
+static int
+machopic_indirection_eq (const void *slot, const void *key)
+{
+  return ((const machopic_indirection *) slot)->ptr_name == (tree) key;
+}
 
-  name = darwin_strip_name_encoding (name);
+/* Return the name of the non-lazy pointer (if STUB_P is false) or
+   stub (if STUB_B is true) corresponding to the given name.  */
 
-  /* Try again, but comparing names this time.  */
-  for (temp = machopic_non_lazy_pointers;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
+const char *
+machopic_indirection_name (rtx sym_ref, bool stub_p)
+{
+  char *buffer;
+  const char *name = XSTR (sym_ref, 0);
+  int namelen = strlen (name);
+  tree ptr_name;
+  machopic_indirection *p;
+  
+  /* Construct the name of the non-lazy pointer or stub.  */
+  if (stub_p)
     {
-      if (TREE_VALUE (temp))
+      int needs_quotes = name_needs_quotes (name);
+      buffer = alloca (strlen ("&L")
+		       + namelen
+		       + strlen (STUB_SUFFIX)
+		       + 2 /* possible quotes */
+		       + 1 /* '\0' */);
+
+      if (needs_quotes)
 	{
-	  temp_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
-	  temp_name = darwin_strip_name_encoding (temp_name);
-	  if (strcmp (name, temp_name) == 0)
-	    return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+	  if (name[0] == '*')
+	    sprintf (buffer, "&\"L%s" STUB_SUFFIX "\"", name + 1);
+	  else
+	    sprintf (buffer, "&\"L%s%s" STUB_SUFFIX "\"", user_label_prefix, 
+		     name);
 	}
+      else if (name[0] == '*')
+	sprintf (buffer, "&L%s" STUB_SUFFIX, name + 1);
+      else
+	sprintf (buffer, "&L%s%s" STUB_SUFFIX, user_label_prefix, name);
+    }
+  else
+    {
+      buffer = alloca (strlen ("&L")
+		       + strlen (user_label_prefix)
+		       + namelen
+		       + strlen (NON_LAZY_POINTER_SUFFIX)
+		       + 1 /* '\0' */);
+      if (name[0] == '*')
+	sprintf (buffer, "&L%s" NON_LAZY_POINTER_SUFFIX, name + 1);
+      else
+	sprintf (buffer, "&L%s%s" NON_LAZY_POINTER_SUFFIX, 
+		 user_label_prefix, name);
     }
 
-  {
-    char *buffer;
-    int namelen = strlen (name);
-    int bufferlen = 0;
-    tree ptr_name;
-
-    buffer = alloca (namelen + strlen("$non_lazy_ptr") + 5);
-
-    strcpy (buffer, "&L");
-    bufferlen = 2;
-    if (name[0] == '*')
-      {
-        memcpy (buffer + bufferlen, name+1, namelen-1+1);
-        bufferlen += namelen-1;
-      }
-    else
-      {
-	strcpy (buffer + bufferlen, user_label_prefix);
-	bufferlen += strlen (user_label_prefix);
-	memcpy (buffer + bufferlen, name, namelen+1);
-        bufferlen += namelen;
-      }
-
-    memcpy (buffer + bufferlen, "$non_lazy_ptr", strlen("$non_lazy_ptr")+1);
-    bufferlen += strlen("$non_lazy_ptr");
-    ptr_name = get_identifier (buffer);
-
-    machopic_non_lazy_pointers
-      = tree_cons (ptr_name, ident, machopic_non_lazy_pointers);
-
-    TREE_USED (machopic_non_lazy_pointers) = 0;
-
-    return IDENTIFIER_POINTER (ptr_name);
-  }
+  /* See if we already have it.  */
+  ptr_name = maybe_get_identifier (buffer);
+  /* If not, create a mapping from the non-lazy pointer to the
+     SYMBOL_REF.  */
+  if (!ptr_name)
+    {
+      void **slot;
+      ptr_name = get_identifier (buffer);
+      p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
+      p->symbol = sym_ref;
+      p->ptr_name = ptr_name;
+      p->stub_p = stub_p;
+      p->used = 0;
+      if (!machopic_indirections)
+	machopic_indirections 
+	  = htab_create_ggc (37, 
+			     machopic_indirection_hash,
+			     machopic_indirection_eq,
+			     /*htab_del=*/NULL);
+      slot = htab_find_slot_with_hash (machopic_indirections, ptr_name,
+				       IDENTIFIER_HASH_VALUE (ptr_name),
+				       INSERT);
+      *((machopic_indirection **) slot) = p;
+    }
+  
+  return IDENTIFIER_POINTER (ptr_name);
 }
 
-static GTY(()) tree machopic_stubs;
-
-/* Return the name of the stub corresponding to the given name,
-   generating a new stub name if necessary.  */
+/* Return the name of the stub for the mcount function.  */
 
-const char *
-machopic_stub_name (const char *name)
+const char*
+machopic_mcount_stub_name (void)
 {
-  tree temp, ident = get_identifier (name);
-  const char *tname;
-
-  for (temp = machopic_stubs;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
-    {
-      if (ident == TREE_VALUE (temp))
-	return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
-      tname = IDENTIFIER_POINTER (TREE_VALUE (temp));
-      if (strcmp (name, tname) == 0)
-	return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
-      /* A library call name might not be section-encoded yet, so try
-	 it against a stripped name.  */
-      if (name[0] != '!'
-	  && tname[0] == '!'
-	  && strcmp (name, tname + 4) == 0)
-	return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
-    }
-
-  name = darwin_strip_name_encoding (name);
-
-  {
-    char *buffer;
-    int bufferlen = 0;
-    int namelen = strlen (name);
-    tree ptr_name;
-    int needs_quotes = name_needs_quotes (name);
-
-    buffer = alloca (namelen + 20);
-
-    if (needs_quotes)
-      {
-        strcpy (buffer, "&\"L");
-        bufferlen = strlen("&\"L");
-      }
-    else
-      {
-        strcpy (buffer, "&L");
-        bufferlen = strlen("&L");
-      }
-    
-    if (name[0] == '*')
-      {
-	memcpy (buffer + bufferlen, name+1, namelen - 1 +1);
-        bufferlen += namelen - 1;
-      }
-    else
-      {
-	strcpy (buffer + bufferlen, user_label_prefix);
-	bufferlen += strlen (user_label_prefix);
-	memcpy (buffer + bufferlen, name, namelen+1);
-        bufferlen += namelen;
-      }
-
-    if (needs_quotes)
-      {
-        memcpy (buffer + bufferlen, "$stub\"", strlen("$stub\"")+1);
-        bufferlen += strlen("$stub\"");
-      }
-    else
-      {
-        memcpy (buffer + bufferlen, "$stub", strlen("$stub")+1);
-        bufferlen += strlen("$stub");
-      }
-    ptr_name = get_identifier (buffer);
-
-    machopic_stubs = tree_cons (ptr_name, ident, machopic_stubs);
-    TREE_USED (machopic_stubs) = 0;
-
-    return IDENTIFIER_POINTER (ptr_name);
-  }
+  return "&L*mcount$stub";
 }
 
+/* If NAME is the name of a stub or a non-lazy pointer , mark the stub
+   or non-lazy pointer as used -- and mark the object to which the
+   pointer/stub refers as used as well, since the pointer/stub will
+   emit a reference to it.  */
+
 void
-machopic_validate_stub_or_non_lazy_ptr (const char *name, int validate_stub)
+machopic_validate_stub_or_non_lazy_ptr (const char *name)
 {
-  const char *real_name;
-  tree temp, ident = get_identifier (name), id2;
+  tree ident = get_identifier (name);
 
-    for (temp = (validate_stub ? machopic_stubs : machopic_non_lazy_pointers);
-         temp != NULL_TREE;
-         temp = TREE_CHAIN (temp))
-      if (ident == TREE_PURPOSE (temp))
-	{
-	  /* Mark both the stub or non-lazy pointer as well as the
-	     original symbol as being referenced.  */
-          TREE_USED (temp) = 1;
-	  if (TREE_CODE (TREE_VALUE (temp)) == IDENTIFIER_NODE)
-	    mark_referenced (TREE_VALUE (temp));
-	  real_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
-	  real_name = darwin_strip_name_encoding (real_name);
-	  id2 = maybe_get_identifier (real_name);
-	  if (id2)
-	    mark_referenced (id2);
-	}
+  machopic_indirection *p;
+  
+  p = ((machopic_indirection *) 
+       (htab_find_with_hash (machopic_indirections, ident,
+			     IDENTIFIER_HASH_VALUE (ident))));
+  if (p)
+    {
+      p->used = 1;
+      mark_referenced (ident);
+      mark_referenced (get_identifier (XSTR (p->symbol, 0)));
+    }
 }
 
 /* Transform ORIG, which may be any data source, to the corresponding
@@ -446,8 +324,7 @@ machopic_indirect_data_reference (rtx orig, rtx reg)
 
   if (GET_CODE (orig) == SYMBOL_REF)
     {
-      const char *name = XSTR (orig, 0);
-      int defined = machopic_data_defined_p (name);
+      int defined = machopic_data_defined_p (orig);
 
       if (defined && MACHO_DYNAMIC_NO_PIC_P)
 	{
@@ -463,8 +340,7 @@ machopic_indirect_data_reference (rtx orig, rtx reg)
       else if (defined)
 	{
 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
-	  rtx pic_base = gen_rtx_SYMBOL_REF (Pmode,
-					     machopic_function_base_name ());
+	  rtx pic_base = machopic_function_base_sym ();
 	  rtx offset = gen_rtx_CONST (Pmode,
 				      gen_rtx_MINUS (Pmode, orig, pic_base));
 #endif
@@ -498,8 +374,9 @@ machopic_indirect_data_reference (rtx orig, rtx reg)
 	  return orig;
 	}
 
-      ptr_ref = gen_rtx_SYMBOL_REF (Pmode,
-				    machopic_non_lazy_ptr_name (name));
+      ptr_ref = (gen_rtx_SYMBOL_REF 
+		 (Pmode, 
+		  machopic_indirection_name (orig, /*stub_p=*/false)));
 
      SYMBOL_REF_DECL (ptr_ref) = SYMBOL_REF_DECL (orig);
 
@@ -575,24 +452,20 @@ machopic_indirect_call_target (rtx target)
   if (GET_CODE (target) != MEM)
     return target;
 
-  if (MACHOPIC_INDIRECT && GET_CODE (XEXP (target, 0)) == SYMBOL_REF)
+  if (MACHOPIC_INDIRECT 
+      && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
+      && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
+	   & MACHO_SYMBOL_FLAG_DEFINED))
     {
-      enum machine_mode mode = GET_MODE (XEXP (target, 0));
-      const char *name = XSTR (XEXP (target, 0), 0);
-
-      /* If the name is already defined, we need do nothing.  */
-      if (name[0] == '!' && name[1] == 'T')
-	return target;
-
-      if (!machopic_name_defined_p (name))
-	{
-	  const char *stub_name = machopic_stub_name (name);
-	  tree decl = SYMBOL_REF_DECL (XEXP (target, 0));
-
-	  XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
-	  SYMBOL_REF_DECL (XEXP (target, 0)) = decl;
-	  RTX_UNCHANGING_P (target) = 1;
-	}
+      rtx sym_ref = XEXP (target, 0);
+      const char *stub_name = machopic_indirection_name (sym_ref, 
+							 /*stub_p=*/true);
+      enum machine_mode mode = GET_MODE (sym_ref);
+      tree decl = SYMBOL_REF_DECL (sym_ref);
+      
+      XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
+      SYMBOL_REF_DECL (XEXP (target, 0)) = decl;
+      RTX_UNCHANGING_P (target) = 1;
     }
 
   return target;
@@ -630,7 +503,7 @@ machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
       if (MACHO_DYNAMIC_NO_PIC_P)
 	pic_base = CONST0_RTX (Pmode);
       else
-      pic_base = gen_rtx_SYMBOL_REF (Pmode, machopic_function_base_name ());
+	pic_base = machopic_function_base_sym ();
 
       if (GET_CODE (orig) == MEM)
 	{
@@ -885,26 +758,31 @@ machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
   return pic_ref;
 }
 
+/* Output the stub or non-lazy pointer in *SLOT, if it has been used.
+   DATA is the FILE* for assembly output.  Called from
+   htab_traverse.  */
 
-void
-machopic_finish (FILE *asm_out_file)
+static int
+machopic_output_indirection (void **slot, void *data)
 {
-  tree temp;
+  machopic_indirection *p = *((machopic_indirection **) slot);
+  FILE *asm_out_file = (FILE *) data;
+  rtx symbol;
+  const char *sym_name;
+  const char *ptr_name;
+  
+  if (!p->used)
+    return 1;
 
-  for (temp = machopic_stubs;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
+  symbol = p->symbol;
+  sym_name = XSTR (symbol, 0);
+  ptr_name = IDENTIFIER_POINTER (p->ptr_name);
+  
+  if (p->stub_p)
     {
-      const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
-      const char *stub_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
       char *sym;
       char *stub;
 
-      if (! TREE_USED (temp))
-	continue;
-
-      sym_name = darwin_strip_name_encoding (sym_name);
-
       sym = alloca (strlen (sym_name) + 2);
       if (sym_name[0] == '*' || sym_name[0] == '&')
 	strcpy (sym, sym_name + 1);
@@ -913,48 +791,47 @@ machopic_finish (FILE *asm_out_file)
       else
 	sprintf (sym, "%s%s", user_label_prefix, sym_name);
 
-      stub = alloca (strlen (stub_name) + 2);
-      if (stub_name[0] == '*' || stub_name[0] == '&')
-	strcpy (stub, stub_name + 1);
+      stub = alloca (strlen (ptr_name) + 2);
+      if (ptr_name[0] == '*' || ptr_name[0] == '&')
+	strcpy (stub, ptr_name + 1);
       else
-	sprintf (stub, "%s%s", user_label_prefix, stub_name);
+	sprintf (stub, "%s%s", user_label_prefix, ptr_name);
 
-      machopic_output_stub (asm_out_file, sym, stub);
+      machopic_output_stub (asm_out_file, sym, stub);    
     }
-
-  for (temp = machopic_non_lazy_pointers;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
+  else if (machopic_symbol_defined_p (symbol))
     {
-      const char *const sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
-      const char *const lazy_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
-
-      if (! TREE_USED (temp))
-	continue;
-
-      if (machopic_ident_defined_p (TREE_VALUE (temp)))
-	{
-	  data_section ();
-	  assemble_align (GET_MODE_ALIGNMENT (Pmode));
-	  assemble_label (lazy_name);
-	  assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
-			    GET_MODE_SIZE (Pmode),
-			    GET_MODE_ALIGNMENT (Pmode), 1);
-	}
-      else
-	{
-	  machopic_nl_symbol_ptr_section ();
-	  assemble_name (asm_out_file, lazy_name);
-	  fprintf (asm_out_file, ":\n");
-
-	  fprintf (asm_out_file, "\t.indirect_symbol ");
-	  assemble_name (asm_out_file, sym_name);
-	  fprintf (asm_out_file, "\n");
-
-	  assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode),
-			    GET_MODE_ALIGNMENT (Pmode), 1);
-	}
+      data_section ();
+      assemble_align (GET_MODE_ALIGNMENT (Pmode));
+      assemble_label (ptr_name);
+      assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
+			GET_MODE_SIZE (Pmode),
+			GET_MODE_ALIGNMENT (Pmode), 1);
     }
+  else
+    {
+      machopic_nl_symbol_ptr_section ();
+      assemble_name (asm_out_file, ptr_name);
+      fprintf (asm_out_file, ":\n");
+      
+      fprintf (asm_out_file, "\t.indirect_symbol ");
+      assemble_name (asm_out_file, sym_name);
+      fprintf (asm_out_file, "\n");
+      
+      assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode),
+			GET_MODE_ALIGNMENT (Pmode), 1);
+    }
+  
+  return 1;
+}
+
+void
+machopic_finish (FILE *asm_out_file)
+{
+  if (machopic_indirections)
+    htab_traverse_noresize (machopic_indirections, 
+			    machopic_output_indirection,
+			    asm_out_file);
 }
 
 int
@@ -966,7 +843,7 @@ machopic_operand_p (rtx op)
 	op = XEXP (op, 0);
 
       if (GET_CODE (op) == SYMBOL_REF)
-	return machopic_name_defined_p (XSTR (op, 0));
+	return machopic_symbol_defined_p (op);
       else
 	return 0;
     }
@@ -977,8 +854,8 @@ machopic_operand_p (rtx op)
   if (GET_CODE (op) == MINUS
       && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
       && GET_CODE (XEXP (op, 1)) == SYMBOL_REF
-      && machopic_name_defined_p (XSTR (XEXP (op, 0), 0))
-      && machopic_name_defined_p (XSTR (XEXP (op, 1), 0)))
+      && machopic_symbol_defined_p (XEXP (op, 0))
+      && machopic_symbol_defined_p (XEXP (op, 1)))
       return 1;
 
   return 0;
@@ -991,140 +868,25 @@ machopic_operand_p (rtx op)
 void
 darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
 {
-  char code = '\0';
-  int defined = 0;
   rtx sym_ref;
-  const char *orig_str;
-  char *new_str;
-  size_t len, new_len;
 
   /* Do the standard encoding things first.  */
   default_encode_section_info (decl, rtl, first);
 
-  /* With the introduction of symbol_ref flags, some of the following
-     code has become redundant and should be removed at some point.  */
+  if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
+    return;
 
-  if ((TREE_CODE (decl) == FUNCTION_DECL
-       || TREE_CODE (decl) == VAR_DECL)
-      && !DECL_EXTERNAL (decl)
+  sym_ref = XEXP (rtl, 0);
+  if (TREE_CODE (decl) == VAR_DECL)
+    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
+
+  if (!DECL_EXTERNAL (decl)
       && (!TREE_PUBLIC (decl) || (!DECL_ONE_ONLY (decl) && !DECL_WEAK (decl)))
       && ((TREE_STATIC (decl)
 	   && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
 	  || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
 	      && DECL_INITIAL (decl) != error_mark_node)))
-    defined = 1;
-
-  if (TREE_CODE (decl) == FUNCTION_DECL)
-    code = (defined ? 'T' : 't');
-  else if (TREE_CODE (decl) == VAR_DECL)
-    code = (defined ? 'D' : 'd');
-
-  if (code == '\0')
-    return;
-
-  sym_ref = XEXP (rtl, 0);
-  orig_str = XSTR (sym_ref, 0);
-  len = strlen (orig_str) + 1;
-
-  if (orig_str[0] == '!')
-    {
-      /* Already encoded; see if we need to change it.  */
-      if (code == orig_str[1])
-	return;
-      /* Yes, tweak a copy of the name and put it in a new string.  */
-      new_str = alloca (len);
-      memcpy (new_str, orig_str, len);
-      new_str[1] = code;
-      XSTR (sym_ref, 0) = ggc_alloc_string (new_str, len);
-    }
-  else
-    {
-      /* Add the encoding.  */
-      new_len = len + 4;
-      new_str = alloca (new_len);
-      new_str[0] = '!';
-      new_str[1] = code;
-      new_str[2] = '_';
-      new_str[3] = '_';
-      memcpy (new_str + 4, orig_str, len);
-      XSTR (sym_ref, 0) = ggc_alloc_string (new_str, new_len);
-    }
-  /* The non-lazy pointer list may have captured references to the
-     old encoded name, change them.  */
-  if (TREE_CODE (decl) == VAR_DECL)
-    update_non_lazy_ptrs (XSTR (sym_ref, 0));
-  else
-    update_stubs (XSTR (sym_ref, 0));
-}
-
-/* Undo the effects of the above.  */
-
-const char *
-darwin_strip_name_encoding (const char *str)
-{
-  return str[0] == '!' ? str + 4 : str;
-}
-
-/* Scan the list of non-lazy pointers and update any recorded names whose
-   stripped name matches the argument.  */
-
-static void
-update_non_lazy_ptrs (const char *name)
-{
-  const char *name1, *name2;
-  tree temp;
-
-  name1 = darwin_strip_name_encoding (name);
-
-  for (temp = machopic_non_lazy_pointers;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
-    {
-      const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
-
-      if (*sym_name == '!')
-	{
-	  name2 = darwin_strip_name_encoding (sym_name);
-	  if (strcmp (name1, name2) == 0)
-	    {
-	      /* FIXME: This breaks the identifier hash table.  */
-	      IDENTIFIER_NODE_CHECK (TREE_VALUE (temp))->identifier.id.str
-		= (unsigned char *) name;
-	      break;
-	    }
-	}
-    }
-}
-
-/* Scan the list of stubs and update any recorded names whose
-   stripped name matches the argument.  */
-
-static void
-update_stubs (const char *name)
-{
-  const char *name1, *name2;
-  tree temp;
-
-  name1 = darwin_strip_name_encoding (name);
-
-  for (temp = machopic_stubs;
-       temp != NULL_TREE;
-       temp = TREE_CHAIN (temp))
-    {
-      const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
-
-      if (*sym_name == '!')
-	{
-	  name2 = darwin_strip_name_encoding (sym_name);
-	  if (strcmp (name1, name2) == 0)
-	    {
-	      /* FIXME: This breaks the identifier hash table.  */
-	      IDENTIFIER_NODE_CHECK (TREE_VALUE (temp))->identifier.id.str
-		= (unsigned char *) name;
-	      break;
-	    }
-	}
-    }
+    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
 }
 
 void
@@ -1417,14 +1179,12 @@ darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
 void
 darwin_non_lazy_pcrel (FILE *file, rtx addr)
 {
-  const char *str;
   const char *nlp_name;
 
   if (GET_CODE (addr) != SYMBOL_REF)
     abort ();
 
-  str = darwin_strip_name_encoding (XSTR (addr, 0));
-  nlp_name = machopic_non_lazy_ptr_name (str);
+  nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
   fputs ("\t.long\t", file);
   ASM_OUTPUT_LABELREF (file, nlp_name);
   fputs ("-.", file);
diff --git a/gcc/config/darwin.h b/gcc/config/darwin.h
index 3a8206e..14fa7a1 100644
--- a/gcc/config/darwin.h
+++ b/gcc/config/darwin.h
@@ -413,7 +413,7 @@ do { text_section ();							\
 
 /* The RTTI data (e.g., __ti4name) is common and public (and static),
    but it does need to be referenced via indirect PIC data pointers.
-   The machopic_define_name calls are telling the machopic subsystem
+   The machopic_define_symbol calls are telling the machopic subsystem
    that the name *is* defined in this module, so it doesn't need to
    make them indirect.  */
 
@@ -427,7 +427,7 @@ do { text_section ();							\
       if ((TREE_STATIC (DECL)						\
 	   && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL)))		\
           || DECL_INITIAL (DECL))					\
-        machopic_define_name (xname);					\
+        machopic_define_symbol (DECL_RTL (DECL));			\
     if ((TREE_STATIC (DECL)						\
 	 && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL)))		\
         || DECL_INITIAL (DECL))						\
@@ -448,7 +448,7 @@ do { text_section ();							\
       if ((TREE_STATIC (DECL)                                           \
 	   && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL)))             \
           || DECL_INITIAL (DECL))                                       \
-        machopic_define_name (xname);                                   \
+        machopic_define_symbol (DECL_RTL (DECL));                       \
     if ((TREE_STATIC (DECL)                                             \
 	 && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL)))               \
         || DECL_INITIAL (DECL))                                         \
@@ -471,18 +471,18 @@ do { text_section ();							\
 #undef	ASM_OUTPUT_LABELREF
 #define ASM_OUTPUT_LABELREF(FILE,NAME)					     \
   do {									     \
-       const char *xname = darwin_strip_name_encoding (NAME);		     \
+       const char *xname = (NAME);					     \
        if (! strcmp (xname, "<pic base>"))				     \
          machopic_output_function_base_name(FILE);                           \
        else if (xname[0] == '&' || xname[0] == '*')			     \
          {								     \
            int len = strlen (xname);					     \
 	   if (len > 6 && !strcmp ("$stub", xname + len - 5))		     \
-	     machopic_validate_stub_or_non_lazy_ptr (xname, 1);		     \
+	     machopic_validate_stub_or_non_lazy_ptr (xname);		     \
 	   else if (len > 7 && !strcmp ("$stub\"", xname + len - 6))	     \
-	     machopic_validate_stub_or_non_lazy_ptr (xname, 1);		     \
+	     machopic_validate_stub_or_non_lazy_ptr (xname);		     \
 	   else if (len > 14 && !strcmp ("$non_lazy_ptr", xname + len - 13)) \
-	     machopic_validate_stub_or_non_lazy_ptr (xname, 0);		     \
+	     machopic_validate_stub_or_non_lazy_ptr (xname);		     \
 	   fputs (&xname[1], FILE);					     \
 	 }								     \
        else if (xname[0] == '+' || xname[0] == '-')			     \
@@ -514,7 +514,7 @@ do { text_section ();							\
 
 /* Ensure correct alignment of bss data.  */
 
-#undef	ASM_OUTPUT_ALIGNED_DECL_LOCAL
+#undef	ASM_OUTPUT_ALIGNED_DECL_LOCAL					
 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN)	\
   do {									\
     fputs (".lcomm ", (FILE));						\
@@ -524,11 +524,10 @@ do { text_section ();							\
     if ((DECL) && ((TREE_STATIC (DECL)					\
 	 && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL)))		\
         || DECL_INITIAL (DECL)))					\
-      (* targetm.encode_section_info) (DECL, DECL_RTL (DECL), false);	\
-    if ((DECL) && ((TREE_STATIC (DECL)					\
-	 && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL)))		\
-        || DECL_INITIAL (DECL)))					\
-      machopic_define_name (NAME);					\
+      {									\
+	(* targetm.encode_section_info) (DECL, DECL_RTL (DECL), false);	\
+	machopic_define_symbol (DECL_RTL (DECL));			\
+      }									\
   } while (0)
 
 /* The maximum alignment which the object file format can support.
@@ -791,6 +790,12 @@ objc_section_init (void)			\
 #define JUMP_TABLES_IN_TEXT_SECTION 1
 #endif
 
+/* Set on a symbol with SYMBOL_FLAG_FUNCTION or
+   MACHO_SYMBOL_FLAG_VARIABLE to indicate that the function or
+   variable has been defined in this translation unit.  */
+#define MACHO_SYMBOL_FLAG_VARIABLE (SYMBOL_FLAG_MACH_DEP)
+#define MACHO_SYMBOL_FLAG_DEFINED ((SYMBOL_FLAG_MACH_DEP) << 1)
+
 /* Symbolic names for various things we might know about a symbol.  */
 
 enum machopic_addr_class {
@@ -811,7 +816,7 @@ enum machopic_addr_class {
 #undef TARGET_ENCODE_SECTION_INFO
 #define TARGET_ENCODE_SECTION_INFO  darwin_encode_section_info
 #undef TARGET_STRIP_NAME_ENCODING
-#define TARGET_STRIP_NAME_ENCODING  darwin_strip_name_encoding
+#define TARGET_STRIP_NAME_ENCODING  default_strip_name_encoding
 
 #define GEN_BINDER_NAME_FOR_STUB(BUF,STUB,STUB_LENGTH)		\
   do {								\
@@ -847,7 +852,7 @@ enum machopic_addr_class {
 
 #define GEN_LAZY_PTR_NAME_FOR_SYMBOL(BUF,SYMBOL,SYMBOL_LENGTH)	\
   do {								\
-    const char *symbol_ = darwin_strip_name_encoding (SYMBOL);	\
+    const char *symbol_ = (SYMBOL);                             \
     char *buffer_ = (BUF);					\
     if (symbol_[0] == '"')					\
       {								\
diff --git a/gcc/config/i386/darwin.h b/gcc/config/i386/darwin.h
index 030f866..711722a 100644
--- a/gcc/config/i386/darwin.h
+++ b/gcc/config/i386/darwin.h
@@ -143,9 +143,9 @@ Boston, MA 02111-1307, USA.  */
     do {								\
       if (MACHOPIC_INDIRECT)						\
 	{								\
-	  const char *name = machopic_stub_name ("*mcount");		\
+	  const char *name = machopic_mcount_stub_name ();		\
 	  fprintf (FILE, "\tcall %s\n", name+1);  /*  skip '&'  */	\
-	  machopic_validate_stub_or_non_lazy_ptr (name, /*stub:*/1);	\
+	  machopic_validate_stub_or_non_lazy_ptr (name);		\
 	}								\
       else fprintf (FILE, "\tcall mcount\n");				\
     } while (0)
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 95d0d52..da1a7aa 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -15521,8 +15521,10 @@ x86_output_mi_thunk (FILE *file ATTRIBUTE_UNUSED,
 #if TARGET_MACHO
 	if (TARGET_MACHO)
 	  {
-	    const char *ip = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
-	    tmp = gen_rtx_SYMBOL_REF (Pmode, machopic_stub_name (ip));
+	    rtx sym_ref = XEXP (DECL_RTL (function), 0);
+	    tmp = (gen_rtx_SYMBOL_REF 
+		   (Pmode, 
+		    machopic_indirection_name (sym_ref, /*stub_p=*/true)));
 	    tmp = gen_rtx_MEM (QImode, tmp);
 	    xops[0] = tmp;
 	    output_asm_insn ("jmp\t%0", xops);
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index e270f69..02f3092 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -3675,8 +3675,7 @@ rs6000_legitimize_reload_address (rtx x, enum machine_mode mode,
 	{
 	  rtx offset = gen_rtx_CONST (Pmode,
 			 gen_rtx_MINUS (Pmode, x,
-			   gen_rtx_SYMBOL_REF (Pmode,
-			     machopic_function_base_name ())));
+					machopic_function_base_sym ()));
 	  x = gen_rtx_LO_SUM (GET_MODE (x),
 		gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
 		  gen_rtx_HIGH (Pmode, offset)), offset);
@@ -10092,8 +10091,8 @@ print_operand (FILE *file, rtx x, int code)
 	  const char *name = XSTR (x, 0);
 #if TARGET_MACHO
 	  if (MACHOPIC_INDIRECT
-	      && machopic_classify_name (name) == MACHOPIC_UNDEFINED_FUNCTION)
-	    name = machopic_stub_name (name);
+	      && machopic_classify_symbol (x) == MACHOPIC_UNDEFINED_FUNCTION)
+	    name = machopic_indirection_name (x, /*stub_p=*/true);
 #endif
 	  assemble_name (file, name);
 	}
@@ -12958,8 +12957,7 @@ rs6000_emit_prologue (void)
       && flag_pic && current_function_uses_pic_offset_table)
     {
       rtx lr = gen_rtx_REG (Pmode, LINK_REGISTER_REGNUM);
-      const char *picbase = machopic_function_base_name ();
-      rtx src = gen_rtx_SYMBOL_REF (Pmode, picbase);
+      rtx src = machopic_function_base_sym ();
 
       rs6000_maybe_dead (emit_insn (gen_load_macho_picbase (lr, src)));
 
@@ -14456,12 +14454,9 @@ output_profile_hook (int labelno ATTRIBUTE_UNUSED)
 #if TARGET_MACHO
       /* For PIC code, set up a stub and collect the caller's address
 	 from r0, which is where the prologue puts it.  */
-      if (MACHOPIC_INDIRECT)
-	{
-	  mcount_name = machopic_stub_name (mcount_name);
-	  if (current_function_uses_pic_offset_table)
-	    caller_addr_regno = 0;
-	}
+      if (MACHOPIC_INDIRECT
+	  && current_function_uses_pic_offset_table)
+	caller_addr_regno = 0;
 #endif
       emit_library_call (gen_rtx_SYMBOL_REF (Pmode, mcount_name),
 			 0, VOIDmode, 1,
@@ -15902,8 +15897,7 @@ macho_branch_islands (void)
       const char *label =
 	IDENTIFIER_POINTER (BRANCH_ISLAND_LABEL_NAME (branch_island));
       const char *name  =
-	darwin_strip_name_encoding (
-	  IDENTIFIER_POINTER (BRANCH_ISLAND_FUNCTION_NAME (branch_island)));
+	IDENTIFIER_POINTER (BRANCH_ISLAND_FUNCTION_NAME (branch_island));
       char name_buf[512];
       /* Cheap copy of the details from the Darwin ASM_OUTPUT_LABELREF().  */
       if (name[0] == '*' || name[0] == '&')
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 736f31c..df1544a 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -2265,9 +2265,13 @@ output_call_frame_info (int for_eh)
 					          (DECL_ASSEMBLER_NAME (fde->decl))),
 		     "FDE initial location");
 	  else
-	    dw2_asm_output_encoded_addr_rtx (fde_encoding,
-		     gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin),
-		     "FDE initial location");
+	    {
+	      rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
+	      SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
+	      dw2_asm_output_encoded_addr_rtx (fde_encoding,
+					       sym_ref,
+					       "FDE initial location");
+	    }
 	  dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
 				fde->dw_fde_end, fde->dw_fde_begin,
 				"FDE address range");