[Bug tree-optimization/48031] [4.4/4.5 Regression] gcc.c-torture/compile/pr42956.c ICEs gcc on m68k-linux, ivopts related?

[rguenth at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48031

Richard Guenther <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |ASSIGNED
   Last reconfirmed|                            |2011.03.10 11:02:33
                 CC|                            |ebotcazou at gcc dot
                   |                            |gnu.org
         AssignedTo|unassigned at gcc dot       |rguenth at gcc dot gnu.org
                   |gnu.org                     |
     Ever Confirmed|0                           |1

--- Comment #7 from Richard Guenther <rguenth at gcc dot gnu.org> 2011-03-10 11:02:33 UTC ---
First of all, confirmed with a cross.

The issue seems to be with variable-length arrays:

  D.2079_96 = D.2025 /[ex] 2;
  D.2080_21 = &(*D.2050_128)[0]{lb: 0 sz: D.2079_96 * 2}.err;

What happens is that we have an induction variable base of the form
(unsigned int) &((struct Result *) D.2050_128)->err and end up folding
the conversion to an array reference during gimplifying it here

  /* *(foo *)fooarrptr => (*fooarrptr)[0] */
  if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
      && type == TREE_TYPE (TREE_TYPE (subtype)))
    {
      tree type_domain;
      tree min_val = size_zero_node;
      sub = build_fold_indirect_ref_loc (loc, sub);
      type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
      if (type_domain && TYPE_MIN_VALUE (type_domain))
        min_val = TYPE_MIN_VALUE (type_domain);
      return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
                         NULL_TREE);
    }

and then add a lower bound and step element in gimplify_compound_lval:

          if (!TREE_OPERAND (t, 3))
            {
              tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
              tree elmt_size = unshare_expr (array_ref_element_size (t));
              tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));

              /* Divide the element size by the alignment of the element
                 type (above).  */
              elmt_size = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size,
factor);

              if (!is_gimple_min_invariant (elmt_size))
                {
                  TREE_OPERAND (t, 3) = elmt_size;
                  tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
                                        post_p, is_gimple_reg,
                                        fb_rvalue);
                  ret = MIN (ret, tret);
                }
            }


A fix would be for example avoiding the folding for variable-sized element
types.  Another one would be to avoid putting in a operand 3 into the
array-ref when the index is equal to the lower bound (but I'm not sure
if that works, if the index is zero would probably work, but then a
variant of the code might still ICE the same way).

It's mixing VLA unaware foldings into the mids of GIMPLE which is the
root of the issue though.  The issue is latent on trunk.

Patch for the first (and safe) idea:

Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c    (revision 170818)
+++ gcc/fold-const.c    (working copy)
@@ -15554,7 +15560,8 @@ fold_indirect_ref_1 (location_t loc, tre
        }
       /* *(foo *)&fooarray => fooarray[0] */
       else if (TREE_CODE (optype) == ARRAY_TYPE
-              && type == TREE_TYPE (optype))
+              && type == TREE_TYPE (optype)
+              && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
        {
          tree type_domain = TYPE_DOMAIN (optype);
          tree min_val = size_zero_node;
@@ -15633,7 +15640,8 @@ fold_indirect_ref_1 (location_t loc, tre

   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
-      && type == TREE_TYPE (TREE_TYPE (subtype)))
+      && type == TREE_TYPE (TREE_TYPE (subtype))
+      && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
     {
       tree type_domain;
       tree min_val = size_zero_node;

Eric, can you see any issues with that and Ada?