Remove build_int_cst_wide_type function.

[Anatoly Sokolov <aesok at post dot ru>]

Hello.


  The build_int_cst_wide_type and double_int_to_tree functions do the same
work but differ only in argument types. The build_int_cst_wide_type get
INT_CST as doule_int type, build_int_cst_wide_type as pair HOST_WIDE_INT.
This patch change all uses build_int_cst_wide_type with double_int_to_tree and
remove build_int_cst_wide_type function.

  Bootstrapped/regtested on x86_64-unknown-linux-gnu for c, c++ and java.

  OK for mainline?

        * double-int.h (double_int_ior): New function.
        * tree.h (build_int_cst_wide_type): Remove.
        * tree.c (build_int_cst_wide_type): Remove.
        (double_int_to_tree, double_int_fits_to_tree_p): Handle size types as
        sign extended.
        * fold-const.c (native_interpret_int): Use double_int_to_tree instead
        of build_int_cst_wide_type.
        * dojump.c (do_jump): (Ditto.).
        * stor-layout.c (set_sizetype): (Ditto.).
        
/java   
        * jcf-parse.c (get_constant): Use double_int_to_tree instead of
        build_int_cst_wide_type.


Index: gcc/java/jcf-parse.c
===================================================================
--- gcc/java/jcf-parse.c        (revision 159109)
+++ gcc/java/jcf-parse.c        (working copy)
@@ -1040,14 +1040,15 @@
       }
     case CONSTANT_Long:
       {
-       unsigned HOST_WIDE_INT num = JPOOL_UINT (jcf, index);
-       unsigned HOST_WIDE_INT lo;
-       HOST_WIDE_INT hi;
-       
-       lshift_double (num, 0, 32, 64, &lo, &hi, 0);
-       num = JPOOL_UINT (jcf, index+1);
-       add_double (lo, hi, num, 0, &lo, &hi);
-       value = build_int_cst_wide_type (long_type_node, lo, hi);
+       unsigned HOST_WIDE_INT num;
+       double_int val;
+
+       num = JPOOL_UINT (jcf, index);
+       val = double_int_lshift (uhwi_to_double_int (num), 32, 64, false);
+       num = JPOOL_UINT (jcf, index + 1);
+       val = double_int_ior (val, uhwi_to_double_int (num));
+
+       value = double_int_to_tree (long_type_node, val);
        break;
       }
 
Index: gcc/tree.c
===================================================================
--- gcc/tree.c  (revision 159109)
+++ gcc/tree.c  (working copy)
@@ -1071,25 +1071,19 @@
   return build_int_cst_wide (type, low1, hi);
 }
 
-/* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
-   and sign extended according to the value range of TYPE.  */
-
-tree
-build_int_cst_wide_type (tree type,
-                        unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
-{
-  fit_double_type (low, high, &low, &high, type);
-  return build_int_cst_wide (type, low, high);
-}
-
 /* Constructs tree in type TYPE from with value given by CST.  Signedness
    of CST is assumed to be the same as the signedness of TYPE.  */
 
 tree
 double_int_to_tree (tree type, double_int cst)
 {
-  cst = double_int_ext (cst, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
+  /* Size types *are* sign extended.  */
+  bool sign_extended_type = (!TYPE_UNSIGNED (type)
+                            || (TREE_CODE (type) == INTEGER_TYPE
+                                && TYPE_IS_SIZETYPE (type)));
 
+  cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
+
   return build_int_cst_wide (type, cst.low, cst.high);
 }
 
@@ -1099,10 +1093,14 @@
 bool
 double_int_fits_to_tree_p (const_tree type, double_int cst)
 {
-  double_int ext = double_int_ext (cst,
-                                  TYPE_PRECISION (type),
-                                  TYPE_UNSIGNED (type));
+  /* Size types *are* sign extended.  */
+  bool sign_extended_type = (!TYPE_UNSIGNED (type)
+                            || (TREE_CODE (type) == INTEGER_TYPE
+                                && TYPE_IS_SIZETYPE (type)));
 
+  double_int ext 
+    = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
+
   return double_int_equal_p (cst, ext);
 }
 
Index: gcc/tree.h
===================================================================
--- gcc/tree.h  (revision 159109)
+++ gcc/tree.h  (working copy)
@@ -4013,8 +4013,6 @@
 extern tree build_int_cst_type (tree, HOST_WIDE_INT);
 extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
 extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
-extern tree build_int_cst_wide_type (tree,
-                                    unsigned HOST_WIDE_INT, HOST_WIDE_INT);
 extern tree build_vector (tree, tree);
 extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *);
 extern tree build_constructor (tree, VEC(constructor_elt,gc) *);
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c    (revision 159109)
+++ gcc/fold-const.c    (working copy)
@@ -7408,13 +7408,14 @@
   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
   int byte, offset, word, words;
   unsigned char value;
-  unsigned int HOST_WIDE_INT lo = 0;
-  HOST_WIDE_INT hi = 0;
+  double_int result;
 
   if (total_bytes > len)
     return NULL_TREE;
   if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
     return NULL_TREE;
+
+  result = double_int_zero;
   words = total_bytes / UNITS_PER_WORD;
 
   for (byte = 0; byte < total_bytes; byte++)
@@ -7436,13 +7437,13 @@
       value = ptr[offset];
 
       if (bitpos < HOST_BITS_PER_WIDE_INT)
-       lo |= (unsigned HOST_WIDE_INT) value << bitpos;
+       result.low |= (unsigned HOST_WIDE_INT) value << bitpos;
       else
-       hi |= (unsigned HOST_WIDE_INT) value
-             << (bitpos - HOST_BITS_PER_WIDE_INT);
+       result.high |= (unsigned HOST_WIDE_INT) value
+                      << (bitpos - HOST_BITS_PER_WIDE_INT);
     }
 
-  return build_int_cst_wide_type (type, lo, hi);
+  return double_int_to_tree (type, result);
 }
 
 
Index: gcc/dojump.c
===================================================================
--- gcc/dojump.c        (revision 159109)
+++ gcc/dojump.c        (working copy)
@@ -539,10 +539,11 @@
                  && prefer_and_bit_test (TYPE_MODE (argtype),
                                          TREE_INT_CST_LOW (shift)))
                {
-                 unsigned HOST_WIDE_INT mask
-                   = (unsigned HOST_WIDE_INT) 1 << TREE_INT_CST_LOW (shift);
+                 double_int mask
+                   = double_int_setbit (double_int_zero, 
+                                        TREE_INT_CST_LOW (shift));
                  do_jump (build2 (BIT_AND_EXPR, argtype, arg,
-                                  build_int_cst_wide_type (argtype, mask, 0)),
+                                  double_int_to_tree (argtype, mask)),
                           clr_label, set_label, setclr_prob);
                  break;
                }
Index: gcc/double-int.h
===================================================================
--- gcc/double-int.h    (revision 159109)
+++ gcc/double-int.h    (working copy)
@@ -126,6 +126,7 @@
 double_int double_int_setbit (double_int, unsigned);
 
 /* Logical operations.  */
+
 static inline double_int
 double_int_not (double_int a)
 {
@@ -134,6 +135,14 @@
   return a;
 }
 
+static inline double_int
+double_int_ior (double_int a, double_int b)
+{
+  a.low |= b.low;
+  a.high |= b.high;
+  return a;
+}
+
 /* Shift operations.  */
 double_int double_int_lshift (double_int, HOST_WIDE_INT, unsigned int, bool);
 double_int double_int_rshift (double_int, HOST_WIDE_INT, unsigned int, bool);
Index: gcc/stor-layout.c
===================================================================
--- gcc/stor-layout.c   (revision 159109)
+++ gcc/stor-layout.c   (working copy)
@@ -2275,9 +2275,7 @@
      sign-extended in a way consistent with force_fit_type.  */
   max = TYPE_MAX_VALUE (sizetype);
   TYPE_MAX_VALUE (sizetype)
-    = build_int_cst_wide_type (sizetype,
-                              TREE_INT_CST_LOW (max),
-                              TREE_INT_CST_HIGH (max));
+    = double_int_to_tree (sizetype, tree_to_double_int (max));
 
   t = make_node (INTEGER_TYPE);
   TYPE_NAME (t) = get_identifier ("bit_size_type");


Anatoly.