From: Richard Sandiford Date: Mon, 2 May 2016 09:40:09 +0000 (+0000) Subject: Add a wi::to_wide helper function X-Git-Tag: basepoints/gcc-8~7230 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=697e0b28cca9e5f3e1ee59131c048ef93014fb2f;p=thirdparty%2Fgcc.git 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 d83a16a97ea6..7b1c8389cada 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2016-05-02 Richard Sandiford + + * 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 * wide-int.h: Update offset_int and widest_int documentation. diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 834950ef422a..49012e143076 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,7 @@ +2016-05-02 Richard Sandiford + + * c-common.c (shorten_compare): Use wi::to_wide. + 2016-04-29 Cesar Philippidis PR middle-end/70626 diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index 3c35a6b43530..d45bf1b67f6b 100644 --- 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 8870a0c98727..812c5445278d 100644 --- 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 8ece0f80306f..3c389ee446e4 100644 --- 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 024cf3d0a539..6e52e3d74da5 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5211,6 +5211,8 @@ namespace wi to_widest (const_tree); generic_wide_int > 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 inline wi::extended_tree ::extended_tree (const_tree t) : m_t (t)