2008-05-08 Richard Guenther <rguenther@suse.de>

	* tree-data-ref.c (dr_analyze_alias): Do not set DR_SUBVARS.
	* tree-data-ref.h (struct dr_alias): Remove subvars field.
	(DR_SUBVARS): Remove.
	* tree-dfa.c (dump_subvars_for): Remove.
	(debug_subvars_for): Likewise.
	(dump_variable): Do not dump subvars.
	(remove_referenced_var): Do not remove subvars.
	* tree-flow-inline.h (clear_call_clobbered): SFTs no longer exist.
	(lookup_subvars_for_var): Remove.
	(get_subvars_for_var): Likewise.
	(get_subvars_at): Likewise.
	(get_first_overlapping_subvar): Likewise.
	(overlap_subvar): Likewise.
	* tree-flow.h (subvar_t): Remove.
	(struct var_ann_d): Remove subvars field.
	* tree-ssa-alias.c (mark_aliases_call_clobbered): Remove queued
	argument.  Remove special handling of SFTs.
	(compute_tag_properties): Likewise.
	(set_initial_properties): Likewise.
	(compute_call_clobbered): Likewise.
	(count_mem_refs): Likewise.
	(compute_memory_partitions): Likewise.
	(compute_flow_insensitive_aliasing): Likewise.
	(setup_pointers_and_addressables): Likewise.
	(new_type_alias): Likewise.
	(struct used_part): Remove.
	(used_portions): Likewise.
	(struct used_part_map): Likewise.
	(used_part_map_eq): Likewise.
	(used_part_map_hash): Likewise.
	(free_used_part_map): Likewise.
	(up_lookup): Likewise.
	(up_insert): Likewise.
	(get_or_create_used_part_for): Likewise.
	(create_sft): Likewise.
	(create_overlap_variables_for): Likewise.
	(find_used_portions): Likewise.
	(create_structure_vars): Likewise.
	* tree.def (STRUCT_FIELD_TAG): Remove.
	* tree.h (MTAG_P): Adjust.
	(struct tree_memory_tag): Remove base_for_components and
	unpartitionable flags.
	(struct tree_struct_field_tag): Remove.
	(SFT_PARENT_VAR): Likewise.
	(SFT_OFFSET): Likewise.
	(SFT_SIZE): Likewise.
	(SFT_NONADDRESSABLE_P): Likewise.
	(SFT_ALIAS_SET): Likewise.
	(SFT_UNPARTITIONABLE_P): Likewise.
	(SFT_BASE_FOR_COMPONENTS_P): Likewise.
	(union tree_node): Remove sft field.
	* alias.c (get_alias_set): Remove special handling of SFTs.
	* print-tree.c (print_node): Remove handling of SFTs.
	* tree-dump.c (dequeue_and_dump): Likewise.
	* tree-into-ssa.c (mark_sym_for_renaming): Likewise.
	* tree-nrv.c (dest_safe_for_nrv_p): Remove special handling of SFTs.
	* tree-predcom.c (set_alias_info): Do not set subvars.
	* tree-pretty-print.c (dump_generic_node): Do not handle SFTs.
	* tree-ssa-loop-ivopts.c (get_ref_tag): Likewise.
	* tree-ssa-operands.c (access_can_touch_variable): Likewise.
	(add_vars_for_offset): Remove.
	(add_virtual_operand): Remove special handling of SFTs.
	(add_call_clobber_ops): Likewise.
	(add_call_read_ops): Likewise.
	(get_asm_expr_operands): Likewise.
	(get_modify_stmt_operands): Likewise.
	(get_expr_operands): Likewise.
	(add_to_addressable_set): Likewise.
	* tree-ssa.c (verify_ssa_name): Do not handle SFTs.
	* tree-tailcall.c (suitable_for_tail_opt_p): Likewise.
	* tree-vect-transform.c (vect_create_data_ref_ptr): Do not
	set subvars.
	* tree.c (init_ttree): Remove STRUCT_FIELD_TAG initialization.
	(tree_code_size): Remove STRUCT_FIELD_TAG handling.
	(tree_node_structure): Likewise.
	* tree-ssa-structalias.c (set_uids_in_ptset): Remove special
	handling of SFTs.
	(find_what_p_points_to): Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@135077 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 25 insertions, 241 deletions

diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 8869e6ed95a..c6cc6189b3e 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -1210,49 +1210,6 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
   if (ref && TREE_CODE (ref) == TARGET_MEM_REF)
     return true;
   
-  /* If ALIAS is an SFT, it can't be touched if the offset     
-     and size of the access is not overlapping with the SFT offset and
-     size.  This is only true if we are accessing through a pointer
-     to a type that is the same as SFT_PARENT_VAR.  Otherwise, we may
-     be accessing through a pointer to some substruct of the
-     structure, and if we try to prune there, we will have the wrong
-     offset, and get the wrong answer.
-     i.e., we can't prune without more work if we have something like
-
-     struct gcc_target
-     {
-       struct asm_out
-       {
-         const char *byte_op;
-	 struct asm_int_op
-	 {    
-	   const char *hi;
-	 } aligned_op;
-       } asm_out;
-     } targetm;
-     
-     foo = &targetm.asm_out.aligned_op;
-     return foo->hi;
-
-     SFT.1, which represents hi, will have SFT_OFFSET=32 because in
-     terms of SFT_PARENT_VAR, that is where it is.
-     However, the access through the foo pointer will be at offset 0.  */
-  if (size != -1
-      && TREE_CODE (alias) == STRUCT_FIELD_TAG
-      && base
-      && TREE_TYPE (base) == TREE_TYPE (SFT_PARENT_VAR (alias))
-      && !overlap_subvar (offset, size, alias, NULL))
-    {
-#ifdef ACCESS_DEBUGGING
-      fprintf (stderr, "Access to ");
-      print_generic_expr (stderr, ref, 0);
-      fprintf (stderr, " may not touch ");
-      print_generic_expr (stderr, alias, 0);
-      fprintf (stderr, " in function %s\n", get_name (current_function_decl));
-#endif
-      return false;
-    }
-
   /* Without strict aliasing, it is impossible for a component access
      through a pointer to touch a random variable, unless that
      variable *is* a structure or a pointer.
@@ -1308,7 +1265,7 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
      my_char_ref_1 = (char[1:1] &) &my_char;
      D.874_2 = (*my_char_ref_1)[1]{lb: 1 sz: 1};
   */
-  else if (ref 
+  if (ref 
 	   && flag_strict_aliasing
 	   && TREE_CODE (ref) != INDIRECT_REF
 	   && !MTAG_P (alias)
@@ -1366,61 +1323,6 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
   return true;
 }
 
-/* Add the actual variables accessed, given a member of a points-to set
-   that is the SFT VAR, where the access is of SIZE at OFFSET from VAR.
-   IS_CALL_SITE is true if this is a call, and IS_DEF is true if this is
-   supposed to be a vdef, and false if this should be a VUSE.
-
-   The real purpose of this function is to take a points-to set for a
-   pointer to a structure, say
-
-   struct s {
-     int a;
-     int b;
-   } foo, *foop = &foo;
-
-   and discover which variables an access, such as foop->b, can alias.
-   
-   This is necessary because foop only actually points to foo's first
-   member, so that is all the points-to set contains.  However, an access
-   to foop->a may be touching some single SFT if we have created some
-   SFT's for a structure.  */
-
-static bool
-add_vars_for_offset (tree var, unsigned HOST_WIDE_INT offset,
-		     unsigned HOST_WIDE_INT size, bool is_def)
-{
-  bool added = false;
-  tree subvar;
-  subvar_t sv;
-  unsigned int i;
-
-  /* Adjust offset by the pointed-to location.  */
-  offset += SFT_OFFSET (var);
-
-  /* Add all subvars of var that overlap with the access.
-     Binary search for the first relevant SFT.  */
-  sv = get_subvars_for_var (SFT_PARENT_VAR (var));
-  if (!get_first_overlapping_subvar (sv, offset, size, &i))
-    return false;
-
-  for (; VEC_iterate (tree, sv, i, subvar); ++i)
-    {
-      if (SFT_OFFSET (subvar) > offset
-	  && size <= SFT_OFFSET (subvar) - offset)
-	break;
-
-      if (is_def)
-	append_vdef (subvar);
-      else
-	append_vuse (subvar);
-      added = true;
-    }
-
-  return added;
-}
-
-
 /* Add VAR to the virtual operands array.  FLAGS is as in
    get_expr_operands.  FULL_REF is a tree that contains the entire
    pointer dereference expression, if available, or NULL otherwise.
@@ -1495,50 +1397,24 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags,
 	{
 	  tree al = referenced_var (i);
 
-	  /* For SFTs we have to consider all subvariables of the parent var
-	     if it is a potential points-to location.  */
-	  if (TREE_CODE (al) == STRUCT_FIELD_TAG
-	      && TREE_CODE (var) == NAME_MEMORY_TAG)
-	    {
-	      if (SFT_BASE_FOR_COMPONENTS_P (al))
-		{
-		  /* If AL is the first SFT of a component, it can be used
-		     to find other SFTs at [offset, size] adjacent to it.  */
-		  none_added &= !add_vars_for_offset (al, offset, size,
-						      flags & opf_def);
-		}
-	      else if ((unsigned HOST_WIDE_INT)offset < SFT_SIZE (al))
-		{
-		  /* Otherwise, we only need to consider it if
-		     [offset, size] overlaps with AL.  */
-		  if (flags & opf_def)
-		    append_vdef (al);
-		  else
-		    append_vuse (al);
-		  none_added = false;
-		}
-	    }
+	  /* Call-clobbered tags may have non-call-clobbered
+	     symbols in their alias sets.  Ignore them if we are
+	     adding VOPs for a call site.  */
+	  if (is_call_site && !is_call_clobbered (al))
+	    continue;
+
+	  /* If we do not know the full reference tree or if the access is
+	     unspecified [0, -1], we cannot prune it.  Otherwise try doing
+	     so using access_can_touch_variable.  */
+	  if (full_ref
+	      && !access_can_touch_variable (full_ref, al, offset, size))
+	    continue;
+
+	  if (flags & opf_def)
+	    append_vdef (al);
 	  else
-	    {
-	      /* Call-clobbered tags may have non-call-clobbered
-		 symbols in their alias sets.  Ignore them if we are
-		 adding VOPs for a call site.  */
-	      if (is_call_site && !is_call_clobbered (al))
-		 continue;
-
-	      /* If we do not know the full reference tree or if the access is
-		 unspecified [0, -1], we cannot prune it.  Otherwise try doing
-		 so using access_can_touch_variable.  */
-	      if (full_ref
-		  && !access_can_touch_variable (full_ref, al, offset, size))
-		continue;
-
-	      if (flags & opf_def)
-		append_vdef (al);
-	      else
-		append_vuse (al);
-	      none_added = false;
-	    }
+	    append_vuse (al);
+	  none_added = false;
 	}
 
       if (flags & opf_def)
@@ -1806,11 +1682,6 @@ add_call_clobber_ops (tree stmt, tree callee)
       tree real_var = var;
       bool not_read;
       bool not_written;
-      
-      /* Not read and not written are computed on regular vars, not
-	 subvars, so look at the parent var if this is an SFT. */
-      if (TREE_CODE (var) == STRUCT_FIELD_TAG)
-	real_var = SFT_PARENT_VAR (var);
 
       not_read = not_read_b
 	         ? bitmap_bit_p (not_read_b, DECL_UID (real_var))
@@ -1889,12 +1760,6 @@ add_call_read_ops (tree stmt, tree callee)
       
       clobber_stats.readonly_clobbers++;
 
-      /* Not read and not written are computed on regular vars, not
-	 subvars, so look at the parent var if this is an SFT. */
-
-      if (TREE_CODE (var) == STRUCT_FIELD_TAG)
-	real_var = SFT_PARENT_VAR (var);
-
       not_read = not_read_b ? bitmap_bit_p (not_read_b, DECL_UID (real_var))
 	                    : false;
       
@@ -2022,16 +1887,6 @@ get_asm_expr_operands (tree stmt)
 	EXECUTE_IF_SET_IN_BITMAP (gimple_addressable_vars (cfun), 0, i, bi)
 	  {
 	    tree var = referenced_var (i);
-
-	    /* Subvars are explicitly represented in this list, so we
-	       don't need the original to be added to the clobber ops,
-	       but the original *will* be in this list because we keep
-	       the addressability of the original variable up-to-date
-	       to avoid confusing the back-end.  */
-	    if (var_can_have_subvars (var)
-		&& get_subvars_for_var (var) != NULL)
-	      continue;		
-
 	    add_stmt_operand (&var, s_ann, opf_def | opf_implicit);
 	  }
 	break;
@@ -2052,9 +1907,8 @@ get_modify_stmt_operands (tree stmt, tree expr)
      a preserving definition (VDEF).
 
      Preserving definitions are those that modify a part of an
-     aggregate object for which no subvars have been computed (or the
-     reference does not correspond exactly to one of them). Stores
-     through a pointer are also represented with VDEF operators.
+     aggregate object. Stores through a pointer are also represented
+     with VDEF operators.
 
      We used to distinguish between preserving and killing definitions.
      We always emit preserving definitions now.  */
@@ -2104,7 +1958,6 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
       return;
 
     case SSA_NAME:
-    case STRUCT_FIELD_TAG:
     case SYMBOL_MEMORY_TAG:
     case NAME_MEMORY_TAG:
      add_stmt_operand (expr_p, s_ann, flags);
@@ -2113,25 +1966,8 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
     case VAR_DECL:
     case PARM_DECL:
     case RESULT_DECL:
-      {
-	subvar_t svars;
-	
-	/* Add the subvars for a variable, if it has subvars, to DEFS
-	   or USES.  Otherwise, add the variable itself.  Whether it
-	   goes to USES or DEFS depends on the operand flags.  */
-	if (var_can_have_subvars (expr)
-	    && (svars = get_subvars_for_var (expr)))
-	  {
-	    unsigned int i;
-	    tree subvar;
-	    for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
-	      add_stmt_operand (&subvar, s_ann, flags);
-	  }
-	else
-	  add_stmt_operand (expr_p, s_ann, flags);
-
-	return;
-      }
+      add_stmt_operand (expr_p, s_ann, flags);
+      return;
 
     case MISALIGNED_INDIRECT_REF:
       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
@@ -2154,54 +1990,18 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
       {
 	tree ref;
 	HOST_WIDE_INT offset, size, maxsize;
-	bool none = true;
 
 	if (TREE_THIS_VOLATILE (expr))
 	  s_ann->has_volatile_ops = true;
 
-	/* This component reference becomes an access to all of the
-	   subvariables it can touch, if we can determine that, but
-	   *NOT* the real one.  If we can't determine which fields we
-	   could touch, the recursion will eventually get to a
-	   variable and add *all* of its subvars, or whatever is the
-	   minimum correct subset.  */
 	ref = get_ref_base_and_extent (expr, &offset, &size, &maxsize);
-	if (SSA_VAR_P (ref) && get_subvars_for_var (ref))
-	  {
-	    subvar_t svars = get_subvars_for_var (ref);
-	    unsigned int i;
-	    tree subvar;
-
-	    for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
-	      {
-		bool exact;		
-
-		if (overlap_subvar (offset, maxsize, subvar, &exact))
-		  {
-	            int subvar_flags = flags;
-		    none = false;
-		    add_stmt_operand (&subvar, s_ann, subvar_flags);
-		  }
-	      }
-
-	    if (!none)
-	      flags |= opf_no_vops;
-
-	    if ((DECL_P (ref) && TREE_THIS_VOLATILE (ref))
-		|| (TREE_CODE (ref) == SSA_NAME
-		    && TREE_THIS_VOLATILE (SSA_NAME_VAR (ref))))
-	      s_ann->has_volatile_ops = true;
-	  }
-	else if (TREE_CODE (ref) == INDIRECT_REF)
+	if (TREE_CODE (ref) == INDIRECT_REF)
 	  {
 	    get_indirect_ref_operands (stmt, ref, flags, expr, offset,
 		                       maxsize, false);
 	    flags |= opf_no_vops;
 	  }
 
-	/* Even if we found subvars above we need to ensure to see
-	   immediate uses for d in s.a[d].  In case of s.a having
-	   a subvar or we would miss it otherwise.  */
 	get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
 	
 	if (code == COMPONENT_REF)
@@ -2759,7 +2559,6 @@ void
 add_to_addressable_set (tree ref, bitmap *addresses_taken)
 {
   tree var;
-  subvar_t svars;
 
   gcc_assert (addresses_taken);
 
@@ -2773,23 +2572,8 @@ add_to_addressable_set (tree ref, bitmap *addresses_taken)
     {
       if (*addresses_taken == NULL)
 	*addresses_taken = BITMAP_GGC_ALLOC ();      
-      
-      if (var_can_have_subvars (var)
-	  && (svars = get_subvars_for_var (var)))
-	{
-	  unsigned int i;
-	  tree subvar;
-	  for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
-	    {
-	      bitmap_set_bit (*addresses_taken, DECL_UID (subvar));
-	      TREE_ADDRESSABLE (subvar) = 1;
-	    }
-	}
-      else
-	{
-	  bitmap_set_bit (*addresses_taken, DECL_UID (var));
-	  TREE_ADDRESSABLE (var) = 1;
-	}
+      bitmap_set_bit (*addresses_taken, DECL_UID (var));
+      TREE_ADDRESSABLE (var) = 1;
     }
 }