===================================================================
@@ -6065,7 +6065,7 @@ handle_novops_attribute (tree *node, tre
get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
{
/* Verify the arg number is a constant. */
- if (!cst_fits_uhwi_p (arg_num_expr))
+ if (!tree_fits_uhwi_p (arg_num_expr))
return false;
*valp = TREE_INT_CST_LOW (arg_num_expr);
===================================================================
@@ -8768,7 +8768,7 @@ check_nonnull_arg (void * ARG_UNUSED (ct
get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
{
/* Verify the arg number is a small constant. */
- if (cst_fits_uhwi_p (arg_num_expr))
+ if (tree_fits_uhwi_p (arg_num_expr))
{
*valp = TREE_INT_CST_LOW (arg_num_expr);
return true;
===================================================================
@@ -227,7 +227,7 @@ check_format_string (tree fntype, unsign
static bool
get_constant (tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
{
- if (!cst_fits_uhwi_p (expr))
+ if (!tree_fits_uhwi_p (expr))
{
gcc_assert (!validated_p);
return false;
===================================================================
@@ -96,7 +96,7 @@ solaris_pragma_align (cpp_reader *pfile
}
low = TREE_INT_CST_LOW (x);
- if (!cst_fits_uhwi_p (x)
+ if (!tree_fits_uhwi_p (x)
|| (low != 1 && low != 2 && low != 4 && low != 8 && low != 16
&& low != 32 && low != 64 && low != 128))
{
===================================================================
@@ -1505,8 +1505,8 @@ write_number (unsigned HOST_WIDE_INT num
write_integer_cst (const tree cst)
{
int sign = tree_int_cst_sgn (cst);
-
- if (!cst_fits_shwi_p (cst))
+ widest_int abs_value = wi::abs (wi::to_widest (cst));
+ if (!wi::fits_uhwi_p (abs_value))
{
/* A bignum. We do this in chunks, each of which fits in a
HOST_WIDE_INT. */
@@ -1559,14 +1559,9 @@ write_integer_cst (const tree cst)
else
{
/* A small num. */
- unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
-
if (sign < 0)
- {
- write_char ('n');
- low = -low;
- }
- write_unsigned_number (low);
+ write_char ('n');
+ write_unsigned_number (abs_value.to_uhwi ());
}
}
===================================================================
@@ -16353,8 +16353,7 @@ add_bound_info (dw_die_ref subrange_die,
add_AT_unsigned (subrange_die, bound_attr,
TREE_INT_CST_LOW (bound) & mask);
}
- else if (prec == HOST_BITS_PER_WIDE_INT
- || (cst_fits_uhwi_p (bound) && wi::ges_p (bound, 0)))
+ else if (prec == HOST_BITS_PER_WIDE_INT || tree_fits_uhwi_p (bound))
add_AT_unsigned (subrange_die, bound_attr,
TREE_INT_CST_LOW (bound));
else
===================================================================
@@ -16822,7 +16822,7 @@ ptr_difference_const (tree e1, tree e2,
toffset2 = fold_convert (type, toffset2);
tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
- if (!cst_fits_shwi_p (tdiff))
+ if (!cst_and_fits_in_hwi (tdiff))
return false;
*diff = int_cst_value (tdiff);
===================================================================
@@ -146,7 +146,7 @@ gfc_conv_string_init (tree length, gfc_e
gcc_assert (expr->expr_type == EXPR_CONSTANT);
gcc_assert (expr->ts.type == BT_CHARACTER);
- gcc_assert (cst_fits_uhwi_p (length));
+ gcc_assert (tree_fits_uhwi_p (length));
len = TREE_INT_CST_LOW (length);
slen = expr->value.character.length;
===================================================================
@@ -409,7 +409,7 @@ gfc_can_put_var_on_stack (tree size)
if (gfc_option.flag_max_stack_var_size < 0)
return 1;
- if (!cst_fits_uhwi_p (size))
+ if (!tree_fits_uhwi_p (size))
return 0;
low = TREE_INT_CST_LOW (size);
===================================================================
@@ -2629,7 +2629,7 @@ gfc_string_to_single_character (tree len
{
if (len == NULL
- || !cst_fits_uhwi_p (len)
+ || !tree_fits_uhwi_p (len)
|| !POINTER_TYPE_P (TREE_TYPE (str)))
return NULL_TREE;
===================================================================
@@ -830,7 +830,7 @@ Gcc_backend::type_size(Btype* btype)
if (t == error_mark_node)
return 1;
t = TYPE_SIZE_UNIT(t);
- gcc_assert(cst_fits_uhwi_p (t));
+ gcc_assert(tree_fits_uhwi_p (t));
unsigned HOST_WIDE_INT val_wide = TREE_INT_CST_LOW (t);
size_t ret = static_cast<size_t>(val_wide);
gcc_assert(ret == val_wide);
===================================================================
@@ -318,7 +318,7 @@ handle_novops_attribute (tree *node, tre
get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
{
/* Verify the arg number is a constant. */
- if (!cst_fits_uhwi_p (arg_num_expr))
+ if (!tree_fits_uhwi_p (arg_num_expr))
return false;
*valp = TREE_INT_CST_LOW (arg_num_expr);
===================================================================
@@ -2065,7 +2065,7 @@ strip_offset_1 (tree expr, bool inside_a
switch (code)
{
case INTEGER_CST:
- if (!cst_fits_shwi_p (expr)
+ if (!cst_and_fits_in_hwi (expr)
|| integer_zerop (expr))
return orig_expr;
@@ -2102,7 +2102,7 @@ strip_offset_1 (tree expr, bool inside_a
case MULT_EXPR:
op1 = TREE_OPERAND (expr, 1);
- if (!cst_fits_shwi_p (op1))
+ if (!cst_and_fits_in_hwi (op1))
return orig_expr;
op0 = TREE_OPERAND (expr, 0);
@@ -2124,7 +2124,7 @@ strip_offset_1 (tree expr, bool inside_a
return orig_expr;
step = array_ref_element_size (expr);
- if (!cst_fits_shwi_p (step))
+ if (!cst_and_fits_in_hwi (step))
break;
st = int_cst_value (step);
@@ -2153,8 +2153,8 @@ strip_offset_1 (tree expr, bool inside_a
tmp = component_ref_field_offset (expr);
field = TREE_OPERAND (expr, 1);
if (top_compref
- && cst_fits_shwi_p (tmp)
- && cst_fits_shwi_p (DECL_FIELD_BIT_OFFSET (field)))
+ && cst_and_fits_in_hwi (tmp)
+ && cst_and_fits_in_hwi (DECL_FIELD_BIT_OFFSET (field)))
{
HOST_WIDE_INT boffset, abs_off;
@@ -2417,7 +2417,7 @@ add_autoinc_candidates (struct ivopts_da
if (use_bb->loop_father != data->current_loop
|| !dominated_by_p (CDI_DOMINATORS, data->current_loop->latch, use_bb)
|| stmt_could_throw_p (use->stmt)
- || !cst_fits_shwi_p (step))
+ || !cst_and_fits_in_hwi (step))
return;
cstepi = int_cst_value (step);
@@ -3698,7 +3698,7 @@ force_expr_to_var_cost (tree expr, bool
mult = op0;
if (mult != NULL_TREE
- && cst_fits_shwi_p (TREE_OPERAND (mult, 1))
+ && cst_and_fits_in_hwi (TREE_OPERAND (mult, 1))
&& get_shiftadd_cost (expr, mode, cost0, cost1, mult,
speed, &sa_cost))
return sa_cost;
@@ -3716,10 +3716,10 @@ force_expr_to_var_cost (tree expr, bool
break;
case MULT_EXPR:
- if (cst_fits_shwi_p (op0))
+ if (cst_and_fits_in_hwi (op0))
cost = new_cost (mult_by_coeff_cost (int_cst_value (op0),
mode, speed), 0);
- else if (cst_fits_shwi_p (op1))
+ else if (cst_and_fits_in_hwi (op1))
cost = new_cost (mult_by_coeff_cost (int_cst_value (op1),
mode, speed), 0);
else
@@ -4119,7 +4119,7 @@ get_computation_cost_at (struct ivopts_d
redundancy elimination is likely to transform the code so that
it uses value of the variable before increment anyway,
so it is not that much unrealistic. */
- if (cst_fits_shwi_p (cstep))
+ if (cst_and_fits_in_hwi (cstep))
cstepi = int_cst_value (cstep);
else
cstepi = 0;
@@ -4144,7 +4144,7 @@ get_computation_cost_at (struct ivopts_d
(also holds in the case ratio == -1, TODO. */
- if (cst_fits_shwi_p (cbase))
+ if (cst_and_fits_in_hwi (cbase))
{
offset = - ratio * int_cst_value (cbase);
cost = difference_cost (data,
@@ -4597,7 +4597,7 @@ iv_elimination_compare_lt (struct ivopts
/* We need to be able to decide whether candidate is increasing or decreasing
in order to choose the right comparison operator. */
- if (!cst_fits_shwi_p (cand->iv->step))
+ if (!cst_and_fits_in_hwi (cand->iv->step))
return false;
step = int_cst_value (cand->iv->step);
===================================================================
@@ -579,8 +579,8 @@ inverse (tree x, tree mask)
unsigned HOST_WIDE_INT imask;
unsigned HOST_WIDE_INT irslt = 1;
- gcc_assert (cst_fits_shwi_p (x));
- gcc_assert (cst_fits_shwi_p (mask));
+ gcc_assert (cst_and_fits_in_hwi (x));
+ gcc_assert (cst_and_fits_in_hwi (mask));
ix = int_cst_value (x);
imask = int_cst_value (mask);
===================================================================
@@ -295,7 +295,7 @@ dump_mem_details (FILE *file, tree base,
fprintf (file, "(base ");
print_generic_expr (file, base, TDF_SLIM);
fprintf (file, ", step ");
- if (cst_fits_shwi_p (step))
+ if (cst_and_fits_in_hwi (step))
fprintf (file, HOST_WIDE_INT_PRINT_DEC, int_cst_value (step));
else
print_generic_expr (file, step, TDF_TREE);
@@ -336,7 +336,7 @@ find_or_create_group (struct mem_ref_gro
/* If step is an integer constant, keep the list of groups sorted
by decreasing step. */
- if (cst_fits_shwi_p ((*groups)->step) && cst_fits_shwi_p (step)
+ if (cst_and_fits_in_hwi ((*groups)->step) && cst_and_fits_in_hwi (step)
&& int_cst_value ((*groups)->step) < int_cst_value (step))
break;
}
@@ -444,12 +444,12 @@ idx_analyze_ref (tree base, tree *index,
step = iv.step;
if (TREE_CODE (ibase) == POINTER_PLUS_EXPR
- && cst_fits_shwi_p (TREE_OPERAND (ibase, 1)))
+ && cst_and_fits_in_hwi (TREE_OPERAND (ibase, 1)))
{
idelta = int_cst_value (TREE_OPERAND (ibase, 1));
ibase = TREE_OPERAND (ibase, 0);
}
- if (cst_fits_shwi_p (ibase))
+ if (cst_and_fits_in_hwi (ibase))
{
idelta += int_cst_value (ibase);
ibase = build_int_cst (TREE_TYPE (ibase), 0);
@@ -458,7 +458,7 @@ idx_analyze_ref (tree base, tree *index,
if (TREE_CODE (base) == ARRAY_REF)
{
stepsize = array_ref_element_size (base);
- if (!cst_fits_shwi_p (stepsize))
+ if (!cst_and_fits_in_hwi (stepsize))
return false;
imult = int_cst_value (stepsize);
step = fold_build2 (MULT_EXPR, sizetype,
@@ -556,7 +556,7 @@ gather_memory_references_ref (struct loo
/* Limit non-constant step prefetching only to the innermost loops and
only when the step is loop invariant in the entire loop nest. */
- if (!cst_fits_shwi_p (step))
+ if (!cst_and_fits_in_hwi (step))
{
if (loop->inner != NULL)
{
@@ -670,7 +670,7 @@ prune_ref_by_self_reuse (struct mem_ref
bool backward;
/* If the step size is non constant, we cannot calculate prefetch_mod. */
- if (!cst_fits_shwi_p (ref->group->step))
+ if (!cst_and_fits_in_hwi (ref->group->step))
return;
step = int_cst_value (ref->group->step);
@@ -780,7 +780,7 @@ prune_ref_by_group_reuse (struct mem_ref
int align_unit;
/* If the step is non constant we cannot calculate prefetch_before. */
- if (!cst_fits_shwi_p (ref->group->step)) {
+ if (!cst_and_fits_in_hwi (ref->group->step)) {
return;
}
@@ -1145,7 +1145,7 @@ issue_prefetch_ref (struct mem_ref *ref,
for (ap = 0; ap < n_prefetches; ap++)
{
- if (cst_fits_shwi_p (ref->group->step))
+ if (cst_and_fits_in_hwi (ref->group->step))
{
/* Determine the address to prefetch. */
delta = (ahead + ap * ref->prefetch_mod) *
===================================================================
@@ -1474,6 +1474,21 @@ build_low_bits_mask (tree type, unsigned
TYPE_PRECISION (type)));
}
+/* Checks that X is integer constant that can be expressed in (unsigned)
+ HOST_WIDE_INT without loss of precision. */
+
+bool
+cst_and_fits_in_hwi (const_tree x)
+{
+ if (TREE_CODE (x) != INTEGER_CST)
+ return false;
+
+ if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
+ return false;
+
+ return TREE_INT_CST_NUNITS (x) == 1;
+}
+
/* Build a newly constructed TREE_VEC node of length LEN. */
tree
@@ -2669,7 +2684,7 @@ int_size_in_bytes (const_tree type)
type = TYPE_MAIN_VARIANT (type);
t = TYPE_SIZE_UNIT (type);
- if (t && cst_fits_uhwi_p (t))
+ if (t && tree_fits_uhwi_p (t))
return TREE_INT_CST_LOW (t);
else
return -1;
@@ -7235,7 +7250,7 @@ compare_tree_int (const_tree t, unsigned
{
if (tree_int_cst_sgn (t) < 0)
return -1;
- else if (!cst_fits_uhwi_p (t))
+ else if (!tree_fits_uhwi_p (t))
return 1;
else if (TREE_INT_CST_LOW (t) == u)
return 0;
@@ -10473,7 +10488,7 @@ int_cst_value (const_tree x)
unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
/* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
- gcc_assert (cst_fits_shwi_p (x));
+ gcc_assert (cst_and_fits_in_hwi (x));
if (bits < HOST_BITS_PER_WIDE_INT)
{
===================================================================
@@ -3149,34 +3149,6 @@ omp_clause_elt_check (const_tree __t, in
#endif
-/* Checks that X is an integer constant that can be expressed in a signed
- HOST_WIDE_INT without loss of precision. This function differs from
- the tree_fits_* versions in that the signedness of the type of X is
- not considered. */
-
-static inline bool
-cst_fits_shwi_p (const_tree x)
-{
- if (TREE_CODE (x) != INTEGER_CST)
- return false;
-
- return TREE_INT_CST_NUNITS (x) == 1;
-}
-
-/* Checks that X is an integer constant that can be expressed in an unsigned
- HOST_WIDE_INT without loss of precision. This function differs from
- the tree_fits_* versions in that the signedness of the type of X is
- not considered. */
-
-static inline bool
-cst_fits_uhwi_p (const_tree x)
-{
- if (TREE_CODE (x) != INTEGER_CST)
- return false;
-
- return TREE_INT_CST_NUNITS (x) == 1 && TREE_INT_CST_ELT (x, 0) >= 0;
-}
-
/* Compute the number of operands in an expression node NODE. For
tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
otherwise it is looked up from the node's code. */
@@ -3942,6 +3914,7 @@ extern int integer_pow2p (const_tree);
extern int integer_nonzerop (const_tree);
+extern bool cst_and_fits_in_hwi (const_tree);
extern tree num_ending_zeros (const_tree);
/* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of
===================================================================
@@ -1775,7 +1775,7 @@ wi::neg (const T &x, bool *overflow)
inline WI_UNARY_RESULT (T)
wi::abs (const T &x)
{
- return neg_p (x) ? neg (x) : x;
+ return neg_p (x) ? neg (x) : WI_UNARY_RESULT (T) (x);
}
/* Return the result of sign-extending the low OFFSET bits of X. */