Add a wi::to_wide helper function

As Richard says, we ought to have a convenient way of converting
an INTEGER_CST to a wide_int of a particular precision without
having to extract the sign of the INTEGER_CST's type each time.
This patch adds a wi::to_wide helper for that, alongside the
existing wi::to_offset and wi::to_widest.

Tested on x86_64-linux-gnu and aarch64-linux-gnu.

gcc/
	* tree.h (wi::to_wide): New function.
	* expr.c (expand_expr_real_1): Use wi::to_wide.
	* fold-const.c (int_const_binop_1): Likewise.
	(extract_muldiv_1): Likewise.

gcc/c-family/
	* c-common.c (shorten_compare): Use wi::to_wide.

From-SVN: r235721

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d83a16a97ea6be3db166b9795b0f4dd022878771..7b1c8389cadac192e15aa742ad7a1306eb354e3e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2016-05-02  Richard Sandiford  <richard.sandiford@arm.com>
+
+       * tree.h (wi::to_wide): New function.
+       * expr.c (expand_expr_real_1): Use wi::to_wide.
+       * fold-const.c (int_const_binop_1): Likewise.
+       (extract_muldiv_1): Likewise.
+
 2016-05-02  Richard Sandiford  <richard.sandiford@arm.com>
 
        * wide-int.h: Update offset_int and widest_int documentation.

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index 834950ef422a240c4aa66360875d1e7cba115536..49012e1430761e660788dbac26f226bc2a837641 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,7 @@
+2016-05-02  Richard Sandiford  <richard.sandiford@arm.com>
+
+       * c-common.c (shorten_compare): Use wi::to_wide.
+
 2016-04-29  Cesar Philippidis  <cesar@codesourcery.com>
 
        PR middle-end/70626

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 3c35a6b43530bb4e825d38bad071cd8337174ae4..d45bf1b67f6b1eba7cb64444fe9f108d819c0f25 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -4012,10 +4012,9 @@ shorten_compare (location_t loc, tree *op0_ptr, tree *op1_ptr,
          /* Convert primop1 to target type, but do not introduce
             additional overflow.  We know primop1 is an int_cst.  */
          primop1 = force_fit_type (*restype_ptr,
-                                   wide_int::from
-                                     (primop1,
-                                      TYPE_PRECISION (*restype_ptr),
-                                      TYPE_SIGN (TREE_TYPE (primop1))),
+                                   wi::to_wide
+                                    (primop1,
+                                     TYPE_PRECISION (*restype_ptr)),
                                    0, TREE_OVERFLOW (primop1));
        }
       if (type != *restype_ptr)

diff --git a/gcc/expr.c b/gcc/expr.c
index 8870a0c9872747888fa5639c369e81ffc9b89cb5..812c5445278dd61972fe20702232def7075e4a7c 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -9729,10 +9729,9 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
          GET_MODE_PRECISION (TYPE_MODE (type)), we need to extend from
          the former to the latter according to the signedness of the
          type. */
-      temp = immed_wide_int_const (wide_int::from
+      temp = immed_wide_int_const (wi::to_wide
                                   (exp,
-                                   GET_MODE_PRECISION (TYPE_MODE (type)),
-                                   TYPE_SIGN (type)),
+                                   GET_MODE_PRECISION (TYPE_MODE (type))),
                                   TYPE_MODE (type));
       return temp;
 

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 8ece0f80306ffd69ab7cc98e5b4179aa92efe1b2..3c389ee446e48381a8502d48a1f2ead4743a4c34 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -963,8 +963,7 @@ int_const_binop_1 (enum tree_code code, const_tree arg1, const_tree parg2,
   signop sign = TYPE_SIGN (type);
   bool overflow = false;
 
-  wide_int arg2 = wide_int::from (parg2, TYPE_PRECISION (type),
-                                 TYPE_SIGN (TREE_TYPE (parg2)));
+  wide_int arg2 = wi::to_wide (parg2, TYPE_PRECISION (type));
 
   switch (code)
     {
@@ -6397,10 +6396,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
          bool overflow_mul_p;
          signop sign = TYPE_SIGN (ctype);
          unsigned prec = TYPE_PRECISION (ctype);
-         wide_int mul = wi::mul (wide_int::from (op1, prec,
-                                                 TYPE_SIGN (TREE_TYPE (op1))),
-                                 wide_int::from (c, prec,
-                                                 TYPE_SIGN (TREE_TYPE (c))),
+         wide_int mul = wi::mul (wi::to_wide (op1, prec),
+                                 wi::to_wide (c, prec),
                                  sign, &overflow_mul_p);
          overflow_p = TREE_OVERFLOW (c) | TREE_OVERFLOW (op1);
          if (overflow_mul_p

diff --git a/gcc/tree.h b/gcc/tree.h
index 024cf3d0a5399ad018271d0db3eebf14bba39fda..6e52e3d74da56c80bc70b71748f6e8be6451f232 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5211,6 +5211,8 @@ namespace wi
   to_widest (const_tree);
 
   generic_wide_int <extended_tree <ADDR_MAX_PRECISION> > to_offset (const_tree);
+
+  wide_int to_wide (const_tree, unsigned int);
 }
 
 inline unsigned int
@@ -5240,6 +5242,16 @@ wi::to_offset (const_tree t)
   return t;
 }
 
+/* Convert INTEGER_CST T to a wide_int of precision PREC, extending or
+   truncating as necessary.  When extending, use sign extension if T's
+   type is signed and zero extension if T's type is unsigned.  */
+
+inline wide_int
+wi::to_wide (const_tree t, unsigned int prec)
+{
+  return wide_int::from (t, prec, TYPE_SIGN (TREE_TYPE (t)));
+}
+
 template <int N>
 inline wi::extended_tree <N>::extended_tree (const_tree t)
   : m_t (t)