tree-flow-inline.h (var_can_have_subvars): Move ...
authorRichard Guenther <rguenther@suse.de>
Fri, 9 May 2008 09:32:51 +0000 (09:32 +0000)
committerRichard Biener <rguenth@gcc.gnu.org>
Fri, 9 May 2008 09:32:51 +0000 (09:32 +0000)
2008-05-08  Richard Guenther  <rguenther@suse.de>

* tree-flow-inline.h (var_can_have_subvars): Move ...
* tree-ssa-structalias.c (var_can_have_subvars): ... here.
* tree-flow.h (var_can_have_subvars): Remove.
(push_fields_onto_fieldstack): Remove.
(sort_fieldstack): Likewise.
(struct fieldoff): Move ...
* tree-ssa-structalias.c (struct fieldoff): ... here.  Remove
alias_set and base_for_components fields.
(sort_fieldstack): Make static.
(push_fields_onto_fieldstack): Likewise.  Remove code that
handles anything but RECORD_TYPEs.  Remove alias_set and
base_for_components handling.
(create_variable_info_for): Adjust.

From-SVN: r135110

gcc/ChangeLog
gcc/tree-flow-inline.h
gcc/tree-flow.h
gcc/tree-ssa-structalias.c

index 6fb86b0b87c8b26001776d1dd271b129ffe1ae75..b20ba0facf8afe55e9a56cb3a1f3afef4874dcd0 100644 (file)
@@ -1,3 +1,19 @@
+2008-05-08  Richard Guenther  <rguenther@suse.de>
+
+       * tree-flow-inline.h (var_can_have_subvars): Move ...
+       * tree-ssa-structalias.c (var_can_have_subvars): ... here.
+       * tree-flow.h (var_can_have_subvars): Remove.
+       (push_fields_onto_fieldstack): Remove.
+       (sort_fieldstack): Likewise.
+       (struct fieldoff): Move ...
+       * tree-ssa-structalias.c (struct fieldoff): ... here.  Remove
+       alias_set and base_for_components fields.
+       (sort_fieldstack): Make static.
+       (push_fields_onto_fieldstack): Likewise.  Remove code that
+       handles anything but RECORD_TYPEs.  Remove alias_set and
+       base_for_components handling.
+       (create_variable_info_for): Adjust.
+
 2008-05-08  Seongbae Park  <seongbae.park@gmail.com>
 
        * common.opt (Wframe-larger-than=): Shorten the help message
index 7b82ba34090e1086f9c611a6bd91860fdb55cb93..f2fe01e18d40977b0c3e17b1982c73231517afc5 100644 (file)
@@ -1581,36 +1581,6 @@ ref_contains_array_ref (const_tree ref)
   return false;
 }
 
-
-/* Return true if V is a tree that we can have subvars for.
-   Normally, this is any aggregate type.  Also complex
-   types which are not gimple registers can have subvars.  */
-
-static inline bool
-var_can_have_subvars (const_tree v)
-{
-  /* Volatile variables should never have subvars.  */
-  if (TREE_THIS_VOLATILE (v))
-    return false;
-
-  /* Non decls or memory tags can never have subvars.  */
-  if (!DECL_P (v) || MTAG_P (v))
-    return false;
-
-  /* Aggregates can have subvars.  */
-  if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
-    return true;
-
-  /* Complex types variables which are not also a gimple register can
-    have subvars. */
-  if (TREE_CODE (TREE_TYPE (v)) == COMPLEX_TYPE
-      && !DECL_GIMPLE_REG_P (v))
-    return true;
-
-  return false;
-}
-
-
 /* Return true, if the two ranges [POS1, SIZE1] and [POS2, SIZE2]
    overlap.  SIZE1 and/or SIZE2 can be (unsigned)-1 in which case the
    range is open-ended.  Otherwise return false.  */
index fa1522b2aec935e425b5ae13a1ddc288554c7584..848a9d986959d6fd357895f8294d1ba9c050e5c3 100644 (file)
@@ -854,7 +854,6 @@ static inline bool ref_contains_array_ref (const_tree);
 static inline bool array_ref_contains_indirect_ref (const_tree);
 extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *,
                                     HOST_WIDE_INT *, HOST_WIDE_INT *);
-static inline bool var_can_have_subvars (const_tree);
 extern tree create_tag_raw (enum tree_code, tree, const char *);
 extern void delete_mem_ref_stats (struct function *);
 extern void dump_mem_ref_stats (FILE *);
@@ -1169,39 +1168,6 @@ rtx addr_for_mem_ref (struct mem_address *, bool);
 void get_address_description (tree, struct mem_address *);
 tree maybe_fold_tmr (tree);
 
-/* This structure is used during pushing fields onto the fieldstack
-   to track the offset of the field, since bitpos_of_field gives it
-   relative to its immediate containing type, and we want it relative
-   to the ultimate containing object.  */
-
-struct fieldoff
-{
-  /* Type of the field.  */
-  tree type;
-
-  /* Size, in bits, of the field.  */
-  tree size;
-
-  /* Field.  */
-  tree decl;
-
-  /* Offset from the base of the base containing object to this field.  */
-  HOST_WIDE_INT offset;  
-
-  /* Alias set for the field.  */
-  alias_set_type alias_set;
-
-  /* True, if this offset can be a base for further component accesses.  */
-  unsigned base_for_components : 1;
-};
-typedef struct fieldoff fieldoff_s;
-
-DEF_VEC_O(fieldoff_s);
-DEF_VEC_ALLOC_O(fieldoff_s,heap);
-int push_fields_onto_fieldstack (tree, VEC(fieldoff_s,heap) **,
-                                HOST_WIDE_INT, bool *, tree);
-void sort_fieldstack (VEC(fieldoff_s,heap) *);
-
 void init_alias_heapvars (void);
 void delete_alias_heapvars (void);
 unsigned int execute_fixup_cfg (void);
index b9afe3b22e3d2abc70d562ecdfaa06e54de6711a..f368631fa2e915f69e33b9e43c231e576a669ba3 100644 (file)
@@ -3994,6 +3994,30 @@ insert_into_field_list_sorted (varinfo_t base, varinfo_t field)
     }
 }
 
+/* This structure is used during pushing fields onto the fieldstack
+   to track the offset of the field, since bitpos_of_field gives it
+   relative to its immediate containing type, and we want it relative
+   to the ultimate containing object.  */
+
+struct fieldoff
+{
+  /* Type of the field.  */
+  tree type;
+
+  /* Size, in bits, of the field.  */
+  tree size;
+
+  /* Field.  */
+  tree decl;
+
+  /* Offset from the base of the base containing object to this field.  */
+  HOST_WIDE_INT offset;  
+};
+typedef struct fieldoff fieldoff_s;
+
+DEF_VEC_O(fieldoff_s);
+DEF_VEC_ALLOC_O(fieldoff_s,heap);
+
 /* qsort comparison function for two fieldoff's PA and PB */
 
 static int
@@ -4012,7 +4036,7 @@ fieldoff_compare (const void *pa, const void *pb)
 }
 
 /* Sort a fieldstack according to the field offset and sizes.  */
-void
+static void
 sort_fieldstack (VEC(fieldoff_s,heap) *fieldstack)
 {
   qsort (VEC_address (fieldoff_s, fieldstack),
@@ -4021,6 +4045,28 @@ sort_fieldstack (VEC(fieldoff_s,heap) *fieldstack)
         fieldoff_compare);
 }
 
+/* Return true if V is a tree that we can have subvars for.
+   Normally, this is any aggregate type.  Also complex
+   types which are not gimple registers can have subvars.  */
+
+static inline bool
+var_can_have_subvars (const_tree v)
+{
+  /* Volatile variables should never have subvars.  */
+  if (TREE_THIS_VOLATILE (v))
+    return false;
+
+  /* Non decls or memory tags can never have subvars.  */
+  if (!DECL_P (v) || MTAG_P (v))
+    return false;
+
+  /* Aggregates without overlapping fields can have subvars.  */
+  if (TREE_CODE (TREE_TYPE (v)) == RECORD_TYPE)
+    return true;
+
+  return false;
+}
+
 /* Given a TYPE, and a vector of field offsets FIELDSTACK, push all
    the fields of TYPE onto fieldstack, recording their offsets along
    the way.
@@ -4030,172 +4076,63 @@ sort_fieldstack (VEC(fieldoff_s,heap) *fieldstack)
    Returns the number of fields pushed.
 
    HAS_UNION is set to true if we find a union type as a field of
-   TYPE.
-
-   ADDRESSABLE_TYPE is the type of the outermost object that could
-   have its address taken.  */
+   TYPE.  */
 
-int
+static int
 push_fields_onto_fieldstack (tree type, VEC(fieldoff_s,heap) **fieldstack,
-                            HOST_WIDE_INT offset, bool *has_union,
-                            tree addressable_type)
+                            HOST_WIDE_INT offset, bool *has_union)
 {
   tree field;
   int count = 0;
-  unsigned int first_element = VEC_length (fieldoff_s, *fieldstack);
+
+  if (TREE_CODE (type) != RECORD_TYPE)
+    return 0;
 
   /* If the vector of fields is growing too big, bail out early.
      Callers check for VEC_length <= MAX_FIELDS_FOR_FIELD_SENSITIVE, make
      sure this fails.  */
-  if (first_element > MAX_FIELDS_FOR_FIELD_SENSITIVE)
+  if (VEC_length (fieldoff_s, *fieldstack) > MAX_FIELDS_FOR_FIELD_SENSITIVE)
     return 0;
 
-  if (TREE_CODE (type) == COMPLEX_TYPE)
-    {
-      fieldoff_s *real_part, *img_part;
-      real_part = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
-      real_part->type = TREE_TYPE (type);
-      real_part->size = TYPE_SIZE (TREE_TYPE (type));
-      real_part->offset = offset;
-      real_part->decl = NULL_TREE;
-      real_part->alias_set = -1;
-      real_part->base_for_components = false;
-
-      img_part = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
-      img_part->type = TREE_TYPE (type);
-      img_part->size = TYPE_SIZE (TREE_TYPE (type));
-      img_part->offset = offset + TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (type)));
-      img_part->decl = NULL_TREE;
-      img_part->alias_set = -1;
-      img_part->base_for_components = false;
-
-      count = 2;
-    }
-
-  else if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      tree sz = TYPE_SIZE (type);
-      tree elsz = TYPE_SIZE (TREE_TYPE (type));
-      HOST_WIDE_INT nr;
-      int i;
-
-      if (! sz
-         || ! host_integerp (sz, 1)
-         || TREE_INT_CST_LOW (sz) == 0
-         || ! elsz
-         || ! host_integerp (elsz, 1)
-         || TREE_INT_CST_LOW (elsz) == 0)
-       return 0;
-
-      nr = TREE_INT_CST_LOW (sz) / TREE_INT_CST_LOW (elsz);
-      if (nr > SALIAS_MAX_ARRAY_ELEMENTS)
-       return 0;
-
-      for (i = 0; i < nr; ++i)
-       {
-         bool push = false;
-         int pushed = 0;
-
-         if (has_union
-             && (TREE_CODE (TREE_TYPE (type)) == QUAL_UNION_TYPE
-                 || TREE_CODE (TREE_TYPE (type)) == UNION_TYPE))
-           *has_union = true;
-
-         if (!AGGREGATE_TYPE_P (TREE_TYPE (type))) /* var_can_have_subvars */
-           push = true;
-         else if (!(pushed = push_fields_onto_fieldstack
-                    (TREE_TYPE (type),
-                     fieldstack,
-                     offset + i * TREE_INT_CST_LOW (elsz),
-                     has_union,
-                     (TYPE_NONALIASED_COMPONENT (type)
-                      ? addressable_type
-                      : TREE_TYPE (type)))))
-           /* Empty structures may have actual size, like in C++. So
-              see if we didn't push any subfields and the size is
-              nonzero, push the field onto the stack */
-           push = true;
-
-         if (push)
-           {
-             fieldoff_s *pair;
-
-             pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
-             pair->type = TREE_TYPE (type);
-             pair->size = elsz;
-             pair->decl = NULL_TREE;
-             pair->offset = offset + i * TREE_INT_CST_LOW (elsz);
-             if (TYPE_NONALIASED_COMPONENT (type))
-               pair->alias_set = get_alias_set (addressable_type);
-             else
-               pair->alias_set = -1;
-             pair->base_for_components = false;
-             count++;
-           }
-         else
-           count += pushed;
-       }
-    }
-
-  else
-    {
-      for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
-       if (TREE_CODE (field) == FIELD_DECL)
+  for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+    if (TREE_CODE (field) == FIELD_DECL)
+      {
+       bool push = false;
+       int pushed = 0;
+
+       if (has_union
+           && (TREE_CODE (TREE_TYPE (field)) == QUAL_UNION_TYPE
+               || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
+         *has_union = true;
+
+       if (!var_can_have_subvars (field))
+         push = true;
+       else if (!(pushed = push_fields_onto_fieldstack
+                  (TREE_TYPE (field),
+                   fieldstack,
+                   offset + bitpos_of_field (field),
+                   has_union))
+                && (DECL_SIZE (field)
+                    && !integer_zerop (DECL_SIZE (field))))
+         /* Empty structures may have actual size, like in C++.  So
+            see if we didn't push any subfields and the size is
+            nonzero, push the field onto the stack.  */
+         push = true;
+
+       if (push)
          {
-           bool push = false;
-           int pushed = 0;
-
-           if (has_union
-               && (TREE_CODE (TREE_TYPE (field)) == QUAL_UNION_TYPE
-                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
-             *has_union = true;
-
-           if (!var_can_have_subvars (field))
-             push = true;
-           else if (!(pushed = push_fields_onto_fieldstack
-                      (TREE_TYPE (field),
-                       fieldstack,
-                       offset + bitpos_of_field (field),
-                       has_union,
-                       (DECL_NONADDRESSABLE_P (field)
-                        ? addressable_type
-                        : TREE_TYPE (field))))
-                    && ((DECL_SIZE (field)
-                         && !integer_zerop (DECL_SIZE (field)))
-                        || (!DECL_SIZE (field)
-                            && TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)))
-             /* Empty structures may have actual size, like in C++.  So
-                see if we didn't push any subfields and the size is
-                nonzero, push the field onto the stack.  Trailing flexible
-                array members also need a representative to be able to
-                treat taking their address in PTA.  */
-             push = true;
-
-           if (push)
-             {
-               fieldoff_s *pair;
-
-               pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
-               pair->type = TREE_TYPE (field);
-               pair->size = DECL_SIZE (field);
-               pair->decl = field;
-               pair->offset = offset + bitpos_of_field (field);
-               if (DECL_NONADDRESSABLE_P (field))
-                 pair->alias_set = get_alias_set (addressable_type);
-               else
-                 pair->alias_set = -1;
-               pair->base_for_components = false;
-               count++;
-             }
-           else
-             count += pushed;
-          }
-    }
-
-  /* Make sure the first pushed field is marked as eligible for
-     being a base for component references.  */
-  if (count > 0)
-    VEC_index (fieldoff_s, *fieldstack, first_element)->base_for_components = true;
+           fieldoff_s *pair;
+
+           pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
+           pair->type = TREE_TYPE (field);
+           pair->size = DECL_SIZE (field);
+           pair->decl = field;
+           pair->offset = offset + bitpos_of_field (field);
+           count++;
+         }
+       else
+         count += pushed;
+      }
 
   return count;
 }
@@ -4389,8 +4326,7 @@ create_variable_info_for (tree decl, const char *name)
             || TREE_CODE (decltype) == QUAL_UNION_TYPE;
   if (var_can_have_subvars (decl) && use_field_sensitive && !hasunion)
     {
-      push_fields_onto_fieldstack (decltype, &fieldstack, 0, &hasunion,
-                                  decltype);
+      push_fields_onto_fieldstack (decltype, &fieldstack, 0, &hasunion);
       if (hasunion)
        {
          VEC_free (fieldoff_s, heap, fieldstack);
@@ -4398,7 +4334,6 @@ create_variable_info_for (tree decl, const char *name)
        }
     }
 
-
   /* If the variable doesn't have subvars, we may end up needing to
      sort the field list and create fake variables for all the
      fields.  */