[Bug tree-optimization/92868] [10 Regression] ICE: tree check: expected integer_cst, have ssa_name in to_wide, at tree.h:5855

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92868

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #2 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
That code has lots of issues.  Some in patch form as I was going through them:
gimple_call_alloc_size: for the case when size is INTEGER_CST and it is the one
argument alloc_size, I don't see a reason not to return size earlier, there is
no need to wi::to_wide.  I don't see a point in computing rng1[0] and rng2[0]
when nothing really uses it (write-only element).  Some formatting and typo in
comment.

I don't understand why you are using wi::sign_mask, the normal test for
negative wide_int when it is treated as signed integer of the corresponding
precision is wi::neg_p, that is more readable and descriptive.  If something is
tested on the wide ints with extra precision and the ::from was UNSIGNED, that
is of course not possible, but sign_mask will not work in that case either. 
And if it is ::from with SIGNED, neg_p should work fine too.
There is a weird:
          wide_int declsize = wi::to_wide (size);
          if (wi::sign_mask (dstoffrng[0]) > 0)
            declsize += dstoffrng[0];
that condition is never true, sign_mask will only ever return 0 or -1:
  return (HOST_WIDE_INT) (high) < 0 ? -1 : 0;
None of this fixes the ICE.  How exactly to fix that depends on whether *poff
can be something other than INTEGER_CST or not.  If it can be only INTEGER_CST,
then whatever code is setting *poff to non-INTEGER_CST should instead punt or
set to some safe value, whatever, if it can be anything, then while it is fine
to call functions like integer_zerop etc. on that, tree_int_cst_sgn requires
the argument to be INTEGER_CST only, so there needs to be TREE_CODE (*poff) ==
INTEGER_CST && tree_int_csgn (*poff) < 0 instead.  Or perhaps you want
!tree_expr_nonnegative_p (*poff) instead?

--- gcc/builtins.c.jj   2019-12-05 09:47:23.178710510 +0100
+++ gcc/builtins.c      2019-12-09 15:52:55.951404452 +0100
@@ -3746,36 +3746,33 @@ gimple_call_alloc_size (gimple *stmt)
     }

   tree size = gimple_call_arg (stmt, argidx1);
+  if (argidx2 > nargs && TREE_CODE (size) == INTEGER_CST)
+    return size;

   wide_int rng1[2];
   if (TREE_CODE (size) == INTEGER_CST)
-    rng1[0] = rng1[1] = wi::to_wide (size);
+    rng1[1] = wi::to_wide (size);
   else if (TREE_CODE (size) != SSA_NAME
           || get_range_info (size, rng1, rng1 + 1) != VR_RANGE)
     return NULL_TREE;

-  if (argidx2 > nargs && TREE_CODE (size) == INTEGER_CST)
-    return size;
-
   /* To handle ranges do the math in wide_int and return the product
      of the upper bounds as a constant.  Ignore anti-ranges.  */
-  tree n = argidx2 < nargs ? gimple_call_arg (stmt, argidx2) :
integer_one_node;
+  tree n
+    = argidx2 < nargs ? gimple_call_arg (stmt, argidx2) : integer_one_node;
   wide_int rng2[2];
   if (TREE_CODE (n) == INTEGER_CST)
-    rng2[0] = rng2[1] = wi::to_wide (n);
+    rng2[1] = wi::to_wide (n);
   else if (TREE_CODE (n) != SSA_NAME
           || get_range_info (n, rng2, rng2 + 1) != VR_RANGE)
     return NULL_TREE;

-  /* Extend to the maximum precsion to avoid overflow.  */
+  /* Extend to the maximum precision to avoid overflow.  */
   const int prec = ADDR_MAX_PRECISION;
-  rng1[0] = wide_int::from (rng1[0], prec, UNSIGNED);
   rng1[1] = wide_int::from (rng1[1], prec, UNSIGNED);
-  rng2[0] = wide_int::from (rng2[0], prec, UNSIGNED);
   rng2[1] = wide_int::from (rng2[1], prec, UNSIGNED);

   /* Return the lesser of SIZE_MAX and the product of the upper bounds.  */
-  rng1[0] = rng1[0] * rng2[0];
   rng1[1] = rng1[1] * rng2[1];
   tree size_max = TYPE_MAX_VALUE (sizetype);
   if (wi::gtu_p (rng1[1], wi::to_wide (size_max, prec)))
@@ -3853,7 +3850,7 @@ compute_objsize (tree dest, int ostype,
                  /* Ignore negative offsets for now.  For others,
                     use the lower bound as the most optimistic
                     estimate of the (remaining) size.  */
-                 if (wi::sign_mask (wioff))
+                 if (wi::neg_p (wioff))
                    ;
                  else if (wi::ltu_p (wioff, wisiz))
                    {
@@ -3882,9 +3879,8 @@ compute_objsize (tree dest, int ostype,

                      /* Ignore negative offsets for now.  For others,
                         use the lower bound as the most optimistic
-                        estimate of the (remaining)size.  */
-                     if (wi::sign_mask (min)
-                         || wi::sign_mask (max))
+                        estimate of the (remaining) size.  */
+                     if (wi::neg_p (min) || wi::neg_p (max))
                        ;
                      else if (wi::ltu_p (min, wisiz))
                        {
@@ -3912,8 +3908,7 @@ compute_objsize (tree dest, int ostype,
   if (!ostype)
     return NULL_TREE;

-  if (TREE_CODE (dest) == ARRAY_REF
-      || TREE_CODE (dest) == MEM_REF)
+  if (TREE_CODE (dest) == ARRAY_REF || TREE_CODE (dest) == MEM_REF)
     {
       tree ref = TREE_OPERAND (dest, 0);
       tree off = TREE_OPERAND (dest, 1);
@@ -3972,7 +3967,7 @@ compute_objsize (tree dest, int ostype,
              *poff = size_binop (PLUS_EXPR, *poff, off);
            }

-         if (wi::sign_mask (offrng[0]) >= 0)
+         if (!wi::neg_p (offrng[0]))
            {
              if (TREE_CODE (size) != INTEGER_CST)
                return NULL_TREE;
@@ -4007,7 +4002,7 @@ compute_objsize (tree dest, int ostype,
            declsize += dstoffrng[0];

          offrng[1] += dstoffrng[1];
-         if (wi::sign_mask (offrng[1]) < 0)
+         if (wi::neg_p (offrng[1]))
            return size_zero_node;

          return wide_int_to_tree (sizetype, declsize);