lto-symtab.c (lto_cgraph_replace_node): Update.

	* lto-symtab.c (lto_cgraph_replace_node): Update.
	* cgraphbuild.c (record_reference, record_type_list,
	record_eh_tables, mark_address, mark_load, mark_store): Update.
	* cgraph.c (cgraph_same_body_alias, dump_cgraph_node,
	cgraph_create_virtual_clone, cgraph_for_node_thunks_and_aliases):
	Update.
	* cgraph.h (symtab_node_def, symtab_node, const_symtab_node): Remove.
	(cgraph_alias_aliased_node, varpool_alias_aliased_node): Update.
	* reload.c: Fix typo in comment.
	* rtlanal.c: Likewise.
	* tree-emultls.c (gen_emutls_addr): Update.
	* ipa-reference.c (analyze_function): Update.
	* cgraphunit.c (cgraph_analyze_function,
	cgraph_process_same_body_aliases, assemble_thunks_and_aliases):
	Update.
	* ipa-ref.c (ipa_record_reference): Reorg to avoid reference types.
	(ipa_remove_reference): Likewise.
	(ipa_remove_all_refering): Rename to ...
	(ipa_remove_all_referring): ... this one; update.
	(ipa_dump_references): Update.
	(ipa_dump_referring): Update.
	(ipa_clone_references): Update.
	(ipa_clone_refering): Rename to ...
	(ipa_clone_referring): ... this one; update.
	(ipa_ref_cannot_lead_to_return): Update.
	(ipa_ref_has_aliases_p): Update.
	* ipa-ref.h (symtab_node_def, symtab_node, const_symtab_node): New
	forward typedefs.
	(ipa_ref_type): Remove.
	(ipa_ref_ptr_u): Remove.
	(ipa_ref): Remove referencing, refered, refered_index, refering_type
	and refered_type; add referring, referred and referred_index.
	(ipa_ref_list): Rename refering to referring.
	(ipa_record_reference, ipa_remove_all_referring, ipa_dump_referring,
	ipa_clone_references, ipa_clone_referring): Update prototypes.
	* lto-cgraph.c (referenced_from_other_partition_p): Update.
	(lto_output_ref): Update.
	(add_references): Update.
	(input_varpool_node): Update.
	(input_refs): Update.
	* ipa-ref-inline.h (ipa_ref_node): Update.
	(ipa_ref_varpool_node): Update.
	(ipa_ref_referring_node); Update.
	(ipa_ref_referring_varpool_node): Update.
	(ipa_ref_referring_ref_list); Update.
	(ipa_ref_referred_ref_list): Update.
	(ipa_ref_list_first_referring): Update.
	(ipa_empty_ref_list): Update.
	(ipa_ref_list_refering_iterate): Rename to ...
	(ipa_ref_list_referring_iterate): ... this one.
	* cse.c: Update comment.
	* ipa-utils.c (ipa_reverse_postorder): Update.
	* tree-ssa-alias.c: Update.
	* ipa-inline.c (reset_edge_caches): Update.
	(update_caller_keys): Update.
	* ipa-inline.h: Update comments.
	* jump.c: Update comment.
	* alias.c: Likewise.
	* ipa.c (process_references): Update.
	(cgraph_remove_unreachable_nodes): Likewise.
	(ipa_discover_readonly_nonaddressable_var): Likewise.
	(cgraph_address_taken_from_non_vtable_p): Likewise.
	* trans-mem.c (ipa_tm_execute): Update.
	* simplify-rtx.c: Fix comment.
	* rtl.c: Fix comment.
	* symtab.c (symtab_unregister_node): Update.
	* varpool.c (dump_varpool_node): Update.
	(varpool_analyze_pending_decls): Update.
	(assemble_aliases): Update.
	(varpool_for_node_and_aliases): Update.

From-SVN: r186564

1 files changed, 53 insertions, 99 deletions

diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c
index 08f5ade..7926eb6a 100644
--- a/gcc/ipa-ref.c
+++ b/gcc/ipa-ref.c
@@ -1,5 +1,5 @@
 /* Interprocedural reference lists.
-   Copyright (C) 2010
+   Copyright (C) 2010, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Jan Hubicka
 
@@ -34,54 +34,28 @@ static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
    of the use and STMT the statement (if it exists).  */
 
 struct ipa_ref *
-ipa_record_reference (struct cgraph_node *refering_node,
-		      struct varpool_node *refering_varpool_node,
-		      struct cgraph_node *refered_node,
-		      struct varpool_node *refered_varpool_node,
+ipa_record_reference (symtab_node referring_node,
+		      symtab_node referred_node,
 		      enum ipa_ref_use use_type, gimple stmt)
 {
   struct ipa_ref *ref;
   struct ipa_ref_list *list, *list2;
   VEC(ipa_ref_t,gc) *old_references;
-  gcc_assert ((!refering_node) ^ (!refering_varpool_node));
-  gcc_assert ((!refered_node) ^ (!refered_varpool_node));
-  gcc_assert (!stmt || refering_node);
-  gcc_assert (use_type != IPA_REF_ALIAS || !stmt);
 
-  list = (refering_node ? &refering_node->symbol.ref_list
-	  : &refering_varpool_node->symbol.ref_list);
+  gcc_checking_assert (!stmt || symtab_function_p (referring_node));
+  gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
+
+  list = &referring_node->symbol.ref_list;
   old_references = list->references;
   VEC_safe_grow (ipa_ref_t, gc, list->references,
 		 VEC_length (ipa_ref_t, list->references) + 1);
   ref = VEC_last (ipa_ref_t, list->references);
 
-  list2 = (refered_node ? &refered_node->symbol.ref_list
-	   : &refered_varpool_node->symbol.ref_list);
-  VEC_safe_push (ipa_ref_ptr, heap, list2->refering, ref);
-  ref->refered_index = VEC_length (ipa_ref_ptr, list2->refering) - 1;
-  if (refering_node)
-    {
-      ref->refering.cgraph_node = refering_node;
-      ref->refering_type = IPA_REF_CGRAPH;
-    }
-  else
-    {
-      ref->refering.varpool_node = refering_varpool_node;
-      ref->refering_type = IPA_REF_VARPOOL;
-      gcc_assert (use_type == IPA_REF_ADDR || use_type == IPA_REF_ALIAS);
-    }
-  if (refered_node)
-    {
-      ref->refered.cgraph_node = refered_node;
-      ref->refered_type = IPA_REF_CGRAPH;
-      gcc_assert (use_type == IPA_REF_ADDR || use_type == IPA_REF_ALIAS);
-    }
-  else
-    {
-      varpool_mark_needed_node (refered_varpool_node);
-      ref->refered.varpool_node = refered_varpool_node;
-      ref->refered_type = IPA_REF_VARPOOL;
-    }
+  list2 = &referred_node->symbol.ref_list;
+  VEC_safe_push (ipa_ref_ptr, heap, list2->referring, ref);
+  ref->referred_index = VEC_length (ipa_ref_ptr, list2->referring) - 1;
+  ref->referring = referring_node;
+  ref->referred = referred_node;
   ref->stmt = stmt;
   ref->use = use_type;
 
@@ -91,8 +65,8 @@ ipa_record_reference (struct cgraph_node *refering_node,
       int i;
       for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
 	VEC_replace (ipa_ref_ptr,
-		     ipa_ref_refered_ref_list (ref)->refering,
-		     ref->refered_index, ref);
+		     ipa_ref_referred_ref_list (ref)->referring,
+		     ref->referred_index, ref);
     }
   return ref;
 }
@@ -102,30 +76,30 @@ ipa_record_reference (struct cgraph_node *refering_node,
 void
 ipa_remove_reference (struct ipa_ref *ref)
 {
-  struct ipa_ref_list *list = ipa_ref_refered_ref_list (ref);
-  struct ipa_ref_list *list2 = ipa_ref_refering_ref_list (ref);
+  struct ipa_ref_list *list = ipa_ref_referred_ref_list (ref);
+  struct ipa_ref_list *list2 = ipa_ref_referring_ref_list (ref);
   VEC(ipa_ref_t,gc) *old_references = list2->references;
   struct ipa_ref *last;
 
-  gcc_assert (VEC_index (ipa_ref_ptr, list->refering, ref->refered_index) == ref);
-  last = VEC_last (ipa_ref_ptr, list->refering);
+  gcc_assert (VEC_index (ipa_ref_ptr, list->referring, ref->referred_index) == ref);
+  last = VEC_last (ipa_ref_ptr, list->referring);
   if (ref != last)
     {
-      VEC_replace (ipa_ref_ptr, list->refering,
-		   ref->refered_index,
-		   VEC_last (ipa_ref_ptr, list->refering));
-      VEC_index (ipa_ref_ptr, list->refering,
-		 ref->refered_index)->refered_index = ref->refered_index;
+      VEC_replace (ipa_ref_ptr, list->referring,
+		   ref->referred_index,
+		   VEC_last (ipa_ref_ptr, list->referring));
+      VEC_index (ipa_ref_ptr, list->referring,
+		 ref->referred_index)->referred_index = ref->referred_index;
     }
-  VEC_pop (ipa_ref_ptr, list->refering);
+  VEC_pop (ipa_ref_ptr, list->referring);
 
   last = VEC_last (ipa_ref_t, list2->references);
   if (ref != last)
     {
       *ref = *last;
       VEC_replace (ipa_ref_ptr,
-		   ipa_ref_refered_ref_list (ref)->refering,
-		   ref->refered_index, ref);
+		   ipa_ref_referred_ref_list (ref)->referring,
+		   ref->referred_index, ref);
     }
   VEC_pop (ipa_ref_t, list2->references);
   gcc_assert (list2->references == old_references);
@@ -145,12 +119,12 @@ ipa_remove_all_references (struct ipa_ref_list *list)
 /* Remove all references in ref list LIST.  */
 
 void
-ipa_remove_all_refering (struct ipa_ref_list *list)
+ipa_remove_all_referring (struct ipa_ref_list *list)
 {
-  while (VEC_length (ipa_ref_ptr, list->refering))
-    ipa_remove_reference (VEC_last (ipa_ref_ptr, list->refering));
-  VEC_free (ipa_ref_ptr, heap, list->refering);
-  list->refering = NULL;
+  while (VEC_length (ipa_ref_ptr, list->referring))
+    ipa_remove_reference (VEC_last (ipa_ref_ptr, list->referring));
+  VEC_free (ipa_ref_ptr, heap, list->referring);
+  list->referring = NULL;
 }
 
 /* Dump references in LIST to FILE.  */
@@ -162,38 +136,27 @@ ipa_dump_references (FILE * file, struct ipa_ref_list *list)
   int i;
   for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
     {
-      if (ref->refered_type == IPA_REF_CGRAPH)
-	{
-	  fprintf (file, " fn:%s/%i (%s)", cgraph_node_asm_name (ipa_ref_node (ref)),
-		   ipa_ref_node (ref)->symbol.order,
-		   ipa_ref_use_name [ref->use]);
-	}
-      else
-	fprintf (file, " var:%s (%s)",
-		 varpool_node_asm_name (ipa_ref_varpool_node (ref)),
-		 ipa_ref_use_name [ref->use]);
+      fprintf (file, "%s/%i (%s)",
+               symtab_node_asm_name (ref->referred),
+               ref->referred->symbol.order,
+	       ipa_ref_use_name [ref->use]);
     }
   fprintf (file, "\n");
 }
 
-/* Dump refering in LIST to FILE.  */
+/* Dump referring in LIST to FILE.  */
 
 void
-ipa_dump_refering (FILE * file, struct ipa_ref_list *list)
+ipa_dump_referring (FILE * file, struct ipa_ref_list *list)
 {
   struct ipa_ref *ref;
   int i;
-  for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
+  for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
     {
-      if (ref->refering_type == IPA_REF_CGRAPH)
-	fprintf (file, " fn:%s/%i (%s)",
-		 cgraph_node_asm_name (ipa_ref_refering_node (ref)),
-		 ipa_ref_refering_node (ref)->symbol.order,
-		 ipa_ref_use_name [ref->use]);
-      else
-	fprintf (file, " var:%s (%s)",
-		 varpool_node_asm_name (ipa_ref_refering_varpool_node (ref)),
-		 ipa_ref_use_name [ref->use]);
+      fprintf (file, "%s/%i (%s)",
+               symtab_node_asm_name (ref->referring),
+               ref->referring->symbol.order,
+	       ipa_ref_use_name [ref->use]);
     }
   fprintf (file, "\n");
 }
@@ -201,46 +164,37 @@ ipa_dump_refering (FILE * file, struct ipa_ref_list *list)
 /* Clone all references from SRC to DEST_NODE or DEST_VARPOOL_NODE.  */
 
 void
-ipa_clone_references (struct cgraph_node *dest_node,
-		      struct varpool_node *dest_varpool_node,
+ipa_clone_references (symtab_node dest_node,
 		      struct ipa_ref_list *src)
 {
   struct ipa_ref *ref;
   int i;
   for (i = 0; ipa_ref_list_reference_iterate (src, i, ref); i++)
-    ipa_record_reference (dest_node, dest_varpool_node,
-			  ref->refered_type == IPA_REF_CGRAPH
-			  ? ipa_ref_node (ref) : NULL,
-			  ref->refered_type == IPA_REF_VARPOOL
-			  ? ipa_ref_varpool_node (ref) : NULL,
+    ipa_record_reference (dest_node,
+			  ref->referred,
 			  ref->use, ref->stmt);
 }
 
-/* Clone all refering from SRC to DEST_NODE or DEST_VARPOOL_NODE.  */
+/* Clone all referring from SRC to DEST_NODE or DEST_VARPOOL_NODE.  */
 
 void
-ipa_clone_refering (struct cgraph_node *dest_node,
-		    struct varpool_node *dest_varpool_node,
+ipa_clone_referring (symtab_node dest_node,
 		    struct ipa_ref_list *src)
 {
   struct ipa_ref *ref;
   int i;
-  for (i = 0; ipa_ref_list_refering_iterate (src, i, ref); i++)
-    ipa_record_reference (
-			  ref->refering_type == IPA_REF_CGRAPH
-			  ? ipa_ref_refering_node (ref) : NULL,
-			  ref->refering_type == IPA_REF_VARPOOL
-			  ? ipa_ref_refering_varpool_node (ref) : NULL,
-			  dest_node, dest_varpool_node,
+  for (i = 0; ipa_ref_list_referring_iterate (src, i, ref); i++)
+    ipa_record_reference (ref->referring,
+			  dest_node,
 			  ref->use, ref->stmt);
 }
 
-/* Return true when execution of REF can load to return from
+/* Return true when execution of REF can lead to return from
    function. */
 bool
 ipa_ref_cannot_lead_to_return (struct ipa_ref *ref)
 {
-  return cgraph_node_cannot_return (ipa_ref_refering_node (ref));
+  return cgraph_node_cannot_return (ipa_ref_referring_node (ref));
 }
 
 /* Return true if list contains an alias.  */
@@ -249,7 +203,7 @@ ipa_ref_has_aliases_p (struct ipa_ref_list *ref_list)
 {
   struct ipa_ref *ref;
   int i;
-  for (i = 0; ipa_ref_list_refering_iterate (ref_list, i, ref); i++)
+  for (i = 0; ipa_ref_list_referring_iterate (ref_list, i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       return true;
   return false;