poly_int: get_ref_base_and_extent

[thirdparty/gcc.git] / gcc / gimple-fold.c

diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 285ece23b0ee28cb531bb188245baa267fda7862..100e013a6031bd9b4eb7aeb2d80aba5241b48386 100644 (file)
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -6333,10 +6333,10 @@ gimple_fold_stmt_to_constant (gimple *stmt, tree (*valueize) (tree))
    is not explicitly available, but it is known to be zero
    such as 'static const int a;'.  */
 static tree
-get_base_constructor (tree base, HOST_WIDE_INT *bit_offset,
+get_base_constructor (tree base, poly_int64_pod *bit_offset,
                      tree (*valueize)(tree))
 {
-  HOST_WIDE_INT bit_offset2, size, max_size;
+  poly_int64 bit_offset2, size, max_size;
   bool reverse;
 
   if (TREE_CODE (base) == MEM_REF)
@@ -6388,7 +6388,7 @@ get_base_constructor (tree base, HOST_WIDE_INT *bit_offset,
     case COMPONENT_REF:
       base = get_ref_base_and_extent (base, &bit_offset2, &size, &max_size,
                                      &reverse);
-      if (max_size == -1 || size != max_size)
+      if (!known_size_p (max_size) || maybe_ne (size, max_size))
        return NULL_TREE;
       *bit_offset +=  bit_offset2;
       return get_base_constructor (base, bit_offset, valueize);
@@ -6599,7 +6599,7 @@ tree
 fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
 {
   tree ctor, idx, base;
-  HOST_WIDE_INT offset, size, max_size;
+  poly_int64 offset, size, max_size;
   tree tem;
   bool reverse;
 
@@ -6625,23 +6625,23 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
       if (TREE_CODE (TREE_OPERAND (t, 1)) == SSA_NAME
          && valueize
          && (idx = (*valueize) (TREE_OPERAND (t, 1)))
-         && TREE_CODE (idx) == INTEGER_CST)
+         && poly_int_tree_p (idx))
        {
          tree low_bound, unit_size;
 
          /* If the resulting bit-offset is constant, track it.  */
          if ((low_bound = array_ref_low_bound (t),
-              TREE_CODE (low_bound) == INTEGER_CST)
+              poly_int_tree_p (low_bound))
              && (unit_size = array_ref_element_size (t),
                  tree_fits_uhwi_p (unit_size)))
            {
-             offset_int woffset
-               = wi::sext (wi::to_offset (idx) - wi::to_offset (low_bound),
+             poly_offset_int woffset
+               = wi::sext (wi::to_poly_offset (idx)
+                           - wi::to_poly_offset (low_bound),
                            TYPE_PRECISION (TREE_TYPE (idx)));
 
-             if (wi::fits_shwi_p (woffset))
+             if (woffset.to_shwi (&offset))
                {
-                 offset = woffset.to_shwi ();
                  /* TODO: This code seems wrong, multiply then check
                     to see if it fits.  */
                  offset *= tree_to_uhwi (unit_size);
@@ -6654,7 +6654,7 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
                    return build_zero_cst (TREE_TYPE (t));
                  /* Out of bound array access.  Value is undefined,
                     but don't fold.  */
-                 if (offset < 0)
+                 if (maybe_lt (offset, 0))
                    return NULL_TREE;
                  /* We can not determine ctor.  */
                  if (!ctor)
@@ -6679,14 +6679,14 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
       if (ctor == error_mark_node)
        return build_zero_cst (TREE_TYPE (t));
       /* We do not know precise address.  */
-      if (max_size == -1 || max_size != size)
+      if (!known_size_p (max_size) || maybe_ne (max_size, size))
        return NULL_TREE;
       /* We can not determine ctor.  */
       if (!ctor)
        return NULL_TREE;
 
       /* Out of bound array access.  Value is undefined, but don't fold.  */
-      if (offset < 0)
+      if (maybe_lt (offset, 0))
        return NULL_TREE;
 
       return fold_ctor_reference (TREE_TYPE (t), ctor, offset, size,