tree-dfa.c (get_ref_base_and_extent): When computing maxsize deal with structures...

2006-02-10  Richard Guenther  <rguenther@suse.de>

        * tree-dfa.c (get_ref_base_and_extent): When computing maxsize
        deal with structures that end in implicitly variable sized arrays.

From-SVN: r110834

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index bdbc2112ef53b5e2026741acfed3321495cab672..59f26709d6fcd905634225f27f24ac8e0ad667d6 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2006-02-10  Richard Guenther  <rguenther@suse.de>
+
+       * tree-dfa.c (get_ref_base_and_extent): When computing maxsize
+       deal with structures that end in implicitly variable sized arrays.
+
 2006-02-09  Zdenek Dvorak <dvorakz@suse.cz>
 
        PR rtl-optimization/24762

diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index 19453780d426968b07bd135ed16399db51b6d7a7..8339a942831a41e67dd97bf72155ca3b9841e085 100644 (file)
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -913,6 +913,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
   HOST_WIDE_INT maxsize = -1;
   tree size_tree = NULL_TREE;
   tree bit_offset = bitsize_zero_node;
+  bool seen_variable_array_ref = false;
 
   gcc_assert (!SSA_VAR_P (exp));
 
@@ -1004,6 +1005,11 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
                                    fold_convert (bitsizetype, index),
                                    bitsize_unit_node);
                bit_offset = size_binop (PLUS_EXPR, bit_offset, index);
+
+               /* An array ref with a constant index up in the structure
+                  hierarchy will constrain the size of any variable array ref
+                  lower in the access hierarchy.  */
+               seen_variable_array_ref = false;
              }
            else
              {
@@ -1019,6 +1025,10 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
                  }
                else
                  maxsize = -1;
+
+               /* Remember that we have seen an array ref with a variable
+                  index.  */
+               seen_variable_array_ref = true;
              }
          }
          break;
@@ -1043,6 +1053,21 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
     }
  done:
 
+  /* We need to deal with variable arrays ending structures such as
+       struct { int length; int a[1]; } x;           x.a[d]
+       struct { struct { int a; int b; } a[1]; } x;  x.a[d].a
+       struct { struct { int a[1]; } a[1]; } x;      x.a[0][d], x.a[d][0]
+     where we do not know maxsize for variable index accesses to
+     the array.  The simplest way to conservatively deal with this
+     is to punt in the case that offset + maxsize reaches the
+     base type boundary.  */
+  if (seen_variable_array_ref
+      && maxsize != -1
+      && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
+      && TREE_INT_CST_LOW (bit_offset) + maxsize
+        == TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
+    maxsize = -1;
+
   /* ???  Due to negative offsets in ARRAY_REF we can end up with
      negative bit_offset here.  We might want to store a zero offset
      in this case.  */