* expr.c (array_ref_element_size): Force aligned_size back to

        sizetype.
        (component_ref_field_offset): Similarly for aligned_offset.
        * tree.c (recompute_tree_invarant_for_addr_expr): Mark raw
        low-bound, element-size, field-offset fields rather than
        computed values.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 00f5745..00e61c6 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2004-08-30  Richard Henderson  <rth@redhat.com>
+
+       * expr.c (array_ref_element_size): Force aligned_size back to
+       sizetype.
+       (component_ref_field_offset): Similarly for aligned_offset.
+       * tree.c (recompute_tree_invarant_for_addr_expr): Mark raw
+       low-bound, element-size, field-offset fields rather than
+       computed values.
+
 2004-08-30  Joseph S. Myers  <jsm@polyomino.org.uk>
 
        * c-parse.in (parmlist_or_identifiers_1): Remove unreachable and

diff --git a/gcc/expr.c b/gcc/expr.c
index d3c3e89..ca19b7a 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -5481,8 +5481,14 @@ array_ref_element_size (tree exp)
   /* If a size was specified in the ARRAY_REF, it's the size measured
      in alignment units of the element type.  So multiply by that value.  */
   if (aligned_size)
-    return size_binop (MULT_EXPR, aligned_size,
-                      size_int (TYPE_ALIGN (elmt_type) / BITS_PER_UNIT));
+    {
+      /* ??? tree_ssa_useless_type_conversion will eliminate casts to
+        sizetype from another type of the same width and signedness.  */
+      if (TREE_TYPE (aligned_size) != sizetype)
+       aligned_size = fold_convert (sizetype, aligned_size);
+      return size_binop (MULT_EXPR, aligned_size,
+                        size_int (TYPE_ALIGN (elmt_type) / BITS_PER_UNIT));
+    }
 
   /* Otherwise, take the size from that of the element type.  Substitute
      any PLACEHOLDER_EXPR that we have.  */
@@ -5541,8 +5547,14 @@ component_ref_field_offset (tree exp)
      in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT.  So multiply by that
      value.  */
   if (aligned_offset)
-    return size_binop (MULT_EXPR, aligned_offset,
-                      size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT));
+    {
+      /* ??? tree_ssa_useless_type_conversion will eliminate casts to
+        sizetype from another type of the same width and signedness.  */
+      if (TREE_TYPE (aligned_offset) != sizetype)
+       aligned_offset = fold_convert (sizetype, aligned_offset);
+      return size_binop (MULT_EXPR, aligned_offset,
+                        size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT));
+    }
 
   /* Otherwise, take the offset from that of the field.  Substitute
      any PLACEHOLDER_EXPR that we have.  */

diff --git a/gcc/tree.c b/gcc/tree.c
index 1c5060e..90e77ab 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -2252,15 +2252,20 @@ do { tree _node = (NODE); \
          && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
        {
          UPDATE_TITCSE (TREE_OPERAND (node, 1));
-         UPDATE_TITCSE (array_ref_low_bound (node));
-         UPDATE_TITCSE (array_ref_element_size (node));
+         if (TREE_OPERAND (node, 2))
+           UPDATE_TITCSE (TREE_OPERAND (node, 2));
+         if (TREE_OPERAND (node, 3))
+           UPDATE_TITCSE (TREE_OPERAND (node, 3));
        }
       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
         FIELD_DECL, apparently.  The G++ front end can put something else
         there, at least temporarily.  */
       else if (TREE_CODE (node) == COMPONENT_REF
               && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
-       UPDATE_TITCSE (component_ref_field_offset (node));
+       {
+         if (TREE_OPERAND (node, 2))
+           UPDATE_TITCSE (TREE_OPERAND (node, 2));
+       }
       else if (TREE_CODE (node) == BIT_FIELD_REF)
        UPDATE_TITCSE (TREE_OPERAND (node, 2));
     }