poly_int: get_ref_base_and_extent

[thirdparty/gcc.git] / gcc / ipa-polymorphic-call.c

diff --git a/gcc/ipa-polymorphic-call.c b/gcc/ipa-polymorphic-call.c
index 2978fa36089e14a5f45970ecbdc25b47833263b5..21ae70bf493e3fae55babd40954b1538f546e96f 100644 (file)
--- a/gcc/ipa-polymorphic-call.c
+++ b/gcc/ipa-polymorphic-call.c
@@ -759,7 +759,7 @@ ipa_polymorphic_call_context::set_by_invariant (tree cst,
                                                tree otr_type,
                                                HOST_WIDE_INT off)
 {
-  HOST_WIDE_INT offset2, size, max_size;
+  poly_int64 offset2, size, max_size;
   bool reverse;
   tree base;
 
@@ -772,7 +772,7 @@ ipa_polymorphic_call_context::set_by_invariant (tree cst,
 
   cst = TREE_OPERAND (cst, 0);
   base = get_ref_base_and_extent (cst, &offset2, &size, &max_size, &reverse);
-  if (!DECL_P (base) || max_size == -1 || max_size != size)
+  if (!DECL_P (base) || !known_size_p (max_size) || maybe_ne (max_size, size))
     return false;
 
   /* Only type inconsistent programs can have otr_type that is
@@ -899,23 +899,21 @@ ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl,
       base_pointer = walk_ssa_copies (base_pointer, &visited);
       if (TREE_CODE (base_pointer) == ADDR_EXPR)
        {
-         HOST_WIDE_INT size, max_size;
-         HOST_WIDE_INT offset2;
+         HOST_WIDE_INT offset2, size;
          bool reverse;
          tree base
-           = get_ref_base_and_extent (TREE_OPERAND (base_pointer, 0),
-                                      &offset2, &size, &max_size, &reverse);
+           = get_ref_base_and_extent_hwi (TREE_OPERAND (base_pointer, 0),
+                                          &offset2, &size, &reverse);
+         if (!base)
+           break;
 
-         if (max_size != -1 && max_size == size)
-           combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base)),
-                                     offset + offset2,
-                                     true,
-                                     NULL /* Do not change outer type.  */);
+         combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base)),
+                                   offset + offset2,
+                                   true,
+                                   NULL /* Do not change outer type.  */);
 
          /* If this is a varying address, punt.  */
-         if ((TREE_CODE (base) == MEM_REF || DECL_P (base))
-             && max_size != -1
-             && max_size == size)
+         if (TREE_CODE (base) == MEM_REF || DECL_P (base))
            {
              /* We found dereference of a pointer.  Type of the pointer
                 and MEM_REF is meaningless, but we can look futher.  */
@@ -1181,7 +1179,7 @@ static tree
 extr_type_from_vtbl_ptr_store (gimple *stmt, struct type_change_info *tci,
                               HOST_WIDE_INT *type_offset)
 {
-  HOST_WIDE_INT offset, size, max_size;
+  poly_int64 offset, size, max_size;
   tree lhs, rhs, base;
   bool reverse;
 
@@ -1263,17 +1261,23 @@ extr_type_from_vtbl_ptr_store (gimple *stmt, struct type_change_info *tci,
            }
          return tci->offset > POINTER_SIZE ? error_mark_node : NULL_TREE;
        }
-      if (offset != tci->offset
-         || size != POINTER_SIZE
-         || max_size != POINTER_SIZE)
+      if (maybe_ne (offset, tci->offset)
+         || maybe_ne (size, POINTER_SIZE)
+         || maybe_ne (max_size, POINTER_SIZE))
        {
          if (dump_file)
-           fprintf (dump_file, "    wrong offset %i!=%i or size %i\n",
-                    (int)offset, (int)tci->offset, (int)size);
-         return offset + POINTER_SIZE <= tci->offset
-                || (max_size != -1
-                    && tci->offset + POINTER_SIZE > offset + max_size)
-                ? error_mark_node : NULL;
+           {
+             fprintf (dump_file, "    wrong offset ");
+             print_dec (offset, dump_file);
+             fprintf (dump_file, "!=%i or size ", (int) tci->offset);
+             print_dec (size, dump_file);
+             fprintf (dump_file, "\n");
+           }
+         return (known_le (offset + POINTER_SIZE, tci->offset)
+                 || (known_size_p (max_size)
+                     && known_gt (tci->offset + POINTER_SIZE,
+                                  offset + max_size))
+                 ? error_mark_node : NULL);
        }
     }
 
@@ -1403,7 +1407,7 @@ check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
       {
        tree op = walk_ssa_copies (gimple_call_arg (stmt, 0));
        tree type = TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
-       HOST_WIDE_INT offset = 0, size, max_size;
+       HOST_WIDE_INT offset = 0;
        bool reverse;
 
        if (dump_file)
@@ -1415,14 +1419,15 @@ check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
        /* See if THIS parameter seems like instance pointer.  */
        if (TREE_CODE (op) == ADDR_EXPR)
          {
-           op = get_ref_base_and_extent (TREE_OPERAND (op, 0), &offset,
-                                         &size, &max_size, &reverse);
-           if (size != max_size || max_size == -1)
+           HOST_WIDE_INT size;
+           op = get_ref_base_and_extent_hwi (TREE_OPERAND (op, 0),
+                                             &offset, &size, &reverse);
+           if (!op)
              {
                 tci->speculative++;
                return csftc_abort_walking_p (tci->speculative);
              }
-           if (op && TREE_CODE (op) == MEM_REF)
+           if (TREE_CODE (op) == MEM_REF)
              {
                if (!tree_fits_shwi_p (TREE_OPERAND (op, 1)))
                  {
@@ -1578,7 +1583,6 @@ ipa_polymorphic_call_context::get_dynamic_type (tree instance,
   if (gimple_code (call) == GIMPLE_CALL)
     {
       tree ref = gimple_call_fn (call);
-      HOST_WIDE_INT offset2, size, max_size;
       bool reverse;
 
       if (TREE_CODE (ref) == OBJ_TYPE_REF)
@@ -1608,10 +1612,11 @@ ipa_polymorphic_call_context::get_dynamic_type (tree instance,
                  && !SSA_NAME_IS_DEFAULT_DEF (ref)
                  && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref)))
                {
+                 HOST_WIDE_INT offset2, size;
                  tree ref_exp = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ref));
                  tree base_ref
-                   = get_ref_base_and_extent (ref_exp, &offset2, &size,
-                                              &max_size, &reverse);
+                   = get_ref_base_and_extent_hwi (ref_exp, &offset2,
+                                                  &size, &reverse);
 
                  /* Finally verify that what we found looks like read from
                     OTR_OBJECT or from INSTANCE with offset OFFSET.  */