===================================================================
@@ -662,8 +662,7 @@ declare_one_free_variable (const void *v
/* Maybe promote to int. */
if (INTEGRAL_TYPE_P (var_type) && COMPLETE_TYPE_P (var_type)
- && INT_CST_LT (TYPE_SIZE (var_type),
- TYPE_SIZE (integer_type_node)))
+ && INT_CST_LT (TYPE_SIZE (var_type), TYPE_SIZE (integer_type_node)))
arg_type = integer_type_node;
else
arg_type = var_type;
===================================================================
@@ -4757,8 +4757,7 @@ build_c_cast (location_t loc, tree type,
}
else if (TREE_OVERFLOW (value))
/* Reset VALUE's overflow flags, ensuring constant sharing. */
- value = wide_int_to_tree (TREE_TYPE (value),
- value);
+ value = wide_int_to_tree (TREE_TYPE (value), value);
}
}
===================================================================
@@ -1143,7 +1143,8 @@ defer_stack_allocation (tree var, bool t
"small" aggregates to the list at all. */
if (optimize == 0
&& (tree_to_uhwi (DECL_SIZE_UNIT (var))
- < (unsigned HOST_WIDE_INT)PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING)))
+ < ((unsigned HOST_WIDE_INT)
+ PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING))))
return false;
return true;
===================================================================
@@ -5390,9 +5390,11 @@ print_die (dw_die_ref die, FILE *outfile
gcc_assert (i > 0);
if (a->dw_attr_val.v.val_wide->elt (i) == 0)
fprintf (outfile, "0x");
- fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, a->dw_attr_val.v.val_wide->elt (--i));
+ fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
+ a->dw_attr_val.v.val_wide->elt (--i));
while (-- i >= 0)
- fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, a->dw_attr_val.v.val_wide->elt (i));
+ fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
+ a->dw_attr_val.v.val_wide->elt (i));
fprintf (outfile, ")");
break;
}
@@ -15108,15 +15110,13 @@ insert_wide_int (const wide_int &val, un
if (WORDS_BIG_ENDIAN)
for (i = (int)get_full_len (val) - 1; i >= 0; i--)
{
- insert_int ((HOST_WIDE_INT) val.elt (i),
- sizeof (HOST_WIDE_INT), dest);
+ insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
dest += sizeof (HOST_WIDE_INT);
}
else
for (i = 0; i < (int)get_full_len (val); i++)
{
- insert_int ((HOST_WIDE_INT) val.elt (i),
- sizeof (HOST_WIDE_INT), dest);
+ insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
dest += sizeof (HOST_WIDE_INT);
}
}
===================================================================
@@ -9721,7 +9721,7 @@ expand_expr_real_1 (tree exp, rtx target
{
tree type = TREE_TYPE (TREE_TYPE (init));
enum machine_mode mode = TYPE_MODE (type);
-
+
if (GET_MODE_CLASS (mode) == MODE_INT
&& GET_MODE_SIZE (mode) == 1)
return gen_int_mode (TREE_STRING_POINTER (init)
===================================================================
@@ -1795,8 +1795,7 @@ fold_convert_const_fixed_from_int (tree
else
di.high = TREE_INT_CST_ELT (arg1, 1);
- overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
- di,
+ overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type), di,
TYPE_UNSIGNED (TREE_TYPE (arg1)),
TYPE_SATURATING (type));
t = build_fixed (type, value);
@@ -6388,7 +6387,7 @@ fold_div_compare (location_t loc,
tree prod, tmp, hi, lo;
tree arg00 = TREE_OPERAND (arg0, 0);
tree arg01 = TREE_OPERAND (arg0, 1);
- signop sign = TYPE_SIGN (TREE_TYPE (arg0));
+ signop sign = TYPE_SIGN (TREE_TYPE (arg0));
bool neg_overflow = false;
bool overflow;
@@ -11785,7 +11784,7 @@ fold_binary_loc (location_t loc,
}
}
}
-
+
t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
if (t1 != NULL_TREE)
return t1;
===================================================================
@@ -985,8 +985,7 @@ trans_this_image (gfc_se * se, gfc_expr
if (INTEGER_CST_P (dim_arg))
{
if (wi::ltu_p (dim_arg, 1)
- || wi::gtu_p (dim_arg,
- GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
+ || wi::gtu_p (dim_arg, GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
gfc_error ("'dim' argument of %s intrinsic at %L is not a valid "
"dimension index", expr->value.function.isym->name,
&expr->where);
===================================================================
@@ -3047,8 +3047,8 @@ fold_const_aggregate_ref_1 (tree t, tree
tree unit_size = array_ref_element_size (t);
/* If the resulting bit-offset is constant, track it. */
- if ((TREE_CODE (low_bound) == INTEGER_CST)
- && (tree_fits_uhwi_p (unit_size)))
+ if (TREE_CODE (low_bound) == INTEGER_CST
+ && tree_fits_uhwi_p (unit_size))
{
offset_int woffset
= wi::sext (wi::to_offset (idx) - wi::to_offset (low_bound),
===================================================================
@@ -3710,6 +3710,7 @@ expand_copysign_bit (enum machine_mode m
op0 = expand_binop (imode, and_optab, op0,
immed_wide_int_const (~mask, imode),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
+
temp = expand_binop (imode, ior_optab, op0, op1,
gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
target = lowpart_subreg_maybe_copy (mode, temp, imode);
===================================================================
@@ -1378,9 +1378,8 @@ real_to_integer (const REAL_VALUE_TYPE *
}
}
-/* Likewise, but producing a wide-int of PRECISION. If
- the value cannot be represented in precision, FAIL is set to
- TRUE. */
+/* Likewise, but producing a wide-int of PRECISION. If the value cannot
+ be represented in precision, *FAIL is set to TRUE. */
wide_int
real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
@@ -1448,8 +1447,8 @@ real_to_integer (const REAL_VALUE_TYPE *
}
#endif
w = SIGSZ * HOST_BITS_PER_LONG + words * HOST_BITS_PER_WIDE_INT;
- result = wide_int::from_array (val,
- (w + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT, w, w);
+ result = wide_int::from_array
+ (val, (w + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT, w);
result = wi::lrshift (result, (words * HOST_BITS_PER_WIDE_INT) - exp);
result = wide_int::from (result, precision, UNSIGNED);
@@ -2152,8 +2151,7 @@ real_from_string3 (REAL_VALUE_TYPE *r, c
void
real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
- HOST_WIDE_INT val,
- signop sgn)
+ HOST_WIDE_INT val, signop sgn)
{
if (val == 0)
get_zero (r, 0);
@@ -2198,9 +2196,10 @@ real_from_integer (REAL_VALUE_TYPE *r, e
else
{
unsigned int len = val_in.get_precision ();
- int i, j, e=0;
+ int i, j, e = 0;
int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT;
- const unsigned int realmax = SIGNIFICAND_BITS/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT;
+ const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT
+ * HOST_BITS_PER_WIDE_INT);
memset (r, 0, sizeof (*r));
r->cl = rvc_normal;
===================================================================
@@ -1248,8 +1248,7 @@ nonimmediate_operand (rtx op, enum machi
return (general_operand (op, mode) && ! CONSTANT_P (op));
}
-/* Return 1 if OP is a register reference or immediate value of mode
- MODE. */
+/* Return 1 if OP is a register reference or immediate value of mode MODE. */
int
nonmemory_operand (rtx op, enum machine_mode mode)
===================================================================
@@ -457,6 +457,7 @@ rtx_equal_p_cb (const_rtx x, const_rtx y
if (XWINT (x, i) != XWINT (y, i))
return 0;
break;
+
case 'n':
case 'i':
if (XINT (x, i) != XINT (y, i))
===================================================================
@@ -350,9 +350,9 @@ struct GTY((chain_next ("RTX_NEXT (&%h)"
union {
/* RTXs are free to use up to 32 bit from here. */
- /* In a CONST_WIDE_INT (aka hwivec_def), this is the number of HOST_WIDE_INTs
- in the hwivec_def. */
- unsigned GTY ((tag ("CONST_WIDE_INT"))) num_elem:32;
+ /* In a CONST_WIDE_INT (aka hwivec_def), this is the number of
+ HOST_WIDE_INTs in the hwivec_def. */
+ unsigned GTY ((tag ("CONST_WIDE_INT"))) num_elem:32;
} GTY ((desc ("GET_CODE (&%0)"))) u2;
/* The first element of the operands of this rtx.
@@ -404,13 +404,13 @@ #define PUT_MODE(RTX, MODE) ((RTX)->mode
for a variable number of things. The principle use is inside
PARALLEL expressions. */
-#define NULL_RTVEC (rtvec) 0
-
struct GTY((variable_size)) rtvec_def {
int num_elem; /* number of elements */
rtx GTY ((length ("%h.num_elem"))) elem[1];
};
+#define NULL_RTVEC (rtvec) 0
+
#define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem)
#define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (NUM))
===================================================================
@@ -1686,7 +1686,7 @@ simplify_const_unary_operation (enum rtx
case CLRSB:
result = wi::shwi (wi::clrsb (op0), mode);
break;
-
+
case CTZ:
result = wi::shwi (wi::ctz (op0), mode);
break;
@@ -5122,7 +5122,7 @@ simplify_immed_subreg (enum machine_mode
value_bit = 8,
value_mask = (1 << value_bit) - 1
};
- unsigned char value[MAX_BITSIZE_MODE_ANY_MODE/value_bit];
+ unsigned char value[MAX_BITSIZE_MODE_ANY_MODE / value_bit];
int value_start;
int i;
int elem;
===================================================================
@@ -1078,7 +1078,7 @@ tm_log_add (basic_block entry_block, tre
&& transaction_invariant_address_p (lp->addr, entry_block)
&& TYPE_SIZE_UNIT (type) != NULL
&& tree_fits_uhwi_p (TYPE_SIZE_UNIT (type))
- && ((HOST_WIDE_INT)(tree_to_uhwi (TYPE_SIZE_UNIT (type)))
+ && ((HOST_WIDE_INT) tree_to_uhwi (TYPE_SIZE_UNIT (type))
< PARAM_VALUE (PARAM_TM_MAX_AGGREGATE_SIZE))
/* We must be able to copy this type normally. I.e., no
special constructors and the like. */
===================================================================
@@ -29,7 +29,6 @@ Free Software Foundation; either version
#include "dumpfile.h"
#include "wide-int-print.h"
-
/* Extends CST as appropriate for the affine combinations COMB. */
widest_int
===================================================================
@@ -881,8 +881,8 @@ copy_ref_info (tree new_ref, tree old_re
&& (tree_to_hwi (TMR_STEP (new_ref))
< align)))))
{
- unsigned int inc = mem_ref_offset (old_ref).to_uhwi ()
- - mem_ref_offset (new_ref).to_uhwi ();
+ unsigned int inc = (mem_ref_offset (old_ref).to_uhwi ()
+ - mem_ref_offset (new_ref).to_uhwi ());
adjust_ptr_info_misalignment (new_pi, inc);
}
else
===================================================================
@@ -489,8 +489,7 @@ set_lattice_value (tree var, prop_value_
|| (new_val.lattice_val == CONSTANT
&& TREE_CODE (new_val.value) == INTEGER_CST
&& (TREE_CODE (old_val->value) != INTEGER_CST
- || new_val.mask
- != old_val->mask)))
+ || new_val.mask != old_val->mask)))
{
/* ??? We would like to delay creation of INTEGER_CSTs from
partially constants here. */
@@ -1749,7 +1748,8 @@ evaluate_stmt (gimple stmt)
{
tree lhs = gimple_get_lhs (stmt);
widest_int nonzero_bits = get_nonzero_bits (lhs);
- widest_int mask = wi::mask <widest_int> (TYPE_PRECISION (TREE_TYPE (lhs)), false);
+ widest_int mask
+ = wi::mask <widest_int> (TYPE_PRECISION (TREE_TYPE (lhs)), false);
if (nonzero_bits != -1 && nonzero_bits != mask)
{
if (!is_constant)
===================================================================
@@ -3498,7 +3498,6 @@ get_shiftadd_cost (tree expr, enum machi
res = add_costs (res, force_expr_to_var_cost (multop, speed));
*cost = res;
-
return true;
}
@@ -3613,7 +3612,6 @@ force_expr_to_var_cost (tree expr, bool
break;
default:
-
/* Just an arbitrary value, FIXME. */
return new_cost (target_spill_cost[speed], 0);
}
===================================================================
@@ -8622,9 +8622,11 @@ simplify_bit_ops_using_ranges (gimple_st
else
return false;
- if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0), &vr0, &may_be_nonzero0, &must_be_nonzero0))
+ if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0), &vr0, &may_be_nonzero0,
+ &must_be_nonzero0))
return false;
- if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1), &vr1, &may_be_nonzero1, &must_be_nonzero1))
+ if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1), &vr1, &may_be_nonzero1,
+ &must_be_nonzero1))
return false;
switch (gimple_assign_rhs_code (stmt))
@@ -9181,7 +9183,6 @@ simplify_float_conversion_using_ranges (
simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
{
gimple stmt = gsi_stmt (*gsi);
-
if (is_gimple_assign (stmt))
{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
===================================================================
@@ -1780,8 +1780,7 @@ real_value_from_int_cst (const_tree type
memset (&d, 0, sizeof d);
real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
- wide_int (i),
- TYPE_SIGN (TREE_TYPE (i)));
+ wide_int (i), TYPE_SIGN (TREE_TYPE (i)));
return d;
}
@@ -6708,7 +6707,7 @@ type_hash_eq (const void *va, const void
case REAL_TYPE:
case BOOLEAN_TYPE:
if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
- return false;
+ return false;
return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
|| tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
TYPE_MAX_VALUE (b->type)))
===================================================================
@@ -759,7 +759,7 @@ #define DECL_UNSIGNED(NODE) \
#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)
/* Same as TYPE_UNSIGNED but converted to SIGNOP. */
-#define TYPE_SIGN(NODE) ((signop)TYPE_UNSIGNED(NODE))
+#define TYPE_SIGN(NODE) ((signop) TYPE_UNSIGNED (NODE))
/* True if overflow wraps around for the given integral type. That
is, TYPE_MAX + 1 == TYPE_MIN. */