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. OK to install?
Thanks,
Richard
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.
Index: gcc/tree.h
===================================================================
--- gcc/tree.h
+++ 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)
Index: gcc/expr.c
===================================================================
--- gcc/expr.c
+++ 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;
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c
+++ 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)
{
@@ -6394,10 +6393,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
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c
+++ 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)
