+2012-09-24 Lawrence Crowl <crowl@google.com>
+
+ * double-int.h (double_int::from_pair): New.
+ (double_int::wide_mul_with_sign): New.
+ (double_int::sub_with_overflow): New.
+ (double_int::neg_with_overflow): New.
+ (double_int::divmod_with_overflow): New.
+ (shwi_to_double_int): Remove.
+ (uhwi_to_double_int): Remove.
+ (double_int_to_shwi): Remove.
+ (double_int_to_uhwi): Remove.
+ (double_int_fits_in_uhwi_p): Remove.
+ (double_int_fits_in_shwi_p): Remove.
+ (double_int_fits_in_hwi_p): Remove.
+ (double_int_mul): Remove.
+ (double_int_mul_with_sign): Remove.
+ (double_int_add): Remove.
+ (double_int_sub): Remove.
+ (double_int_neg): Remove.
+ (double_int_div): Remove.
+ (double_int_sdiv): Remove.
+ (double_int_udiv): Remove.
+ (double_int_mod): Remove.
+ (double_int_smod): Remove.
+ (double_int_umod): Remove.
+ (double_int_divmod): Remove.
+ (double_int_sdivmod): Remove.
+ (double_int_udivmod): Remove.
+ (double_int_multiple_of): Remove.
+ (double_int_setbit): Remove.
+ (double_int_ctz): Remove.
+ (double_int_not): Remove.
+ (double_int_ior): Remove.
+ (double_int_and): Remove.
+ (double_int_and_not): Remove.
+ (double_int_xor): Remove.
+ (double_int_lshift): Remove.
+ (double_int_rshift): Remove.
+ (double_int_lrotate): Remove.
+ (double_int_rrotate): Remove.
+ (double_int_negative_p): Remove.
+ (double_int_cmp): Remove.
+ (double_int_scmp): Remove.
+ (double_int_ucmp): Remove.
+ (double_int_max): Remove.
+ (double_int_smax): Remove.
+ (double_int_umax): Remove.
+ (double_int_min): Remove.
+ (double_int_smin): Remove.
+ (double_int_umin): Remove.
+ (double_int_ext): Remove.
+ (double_int_sext): Remove.
+ (double_int_zext): Remove.
+ (double_int_mask): Remove.
+ (double_int_max_value): Remove.
+ (double_int_min_value): Remove.
+ (double_int_zero_p): Remove.
+ (double_int_one_p): Remove.
+ (double_int_minus_one_p): Remove.
+ (double_int_equal_p): Remove.
+ (double_int_popcount): Remove.
+ (extern add_double_with_sign): Remove.
+ (#define add_double): Remove.
+ (extern neg_double): Remove.
+ (extern mul_double_with_sign): Remove.
+ (extern mul_double_wide_with_sign): Remove.
+ (#define mul_double): Remove.
+ (extern lshift_double): Remove.
+ (extern div_and_round_double): Remove.
+ * double-int.c (add_double_with_sign): Make static.
+ (#defined add_double): Localized from header.
+ (neg_double): Make static.
+ (mul_double_with_sign): Make static.
+ (mul_double_wide_with_sign): Make static.
+ (#defined mul_double): Localized from header.
+ (lshift_double): Make static.
+ (div_and_round_double): Make static.
+ (double_int::wide_mul_with_sign): New.
+ (double_int::sub_with_overflow): New.
+ (double_int::neg_with_overflow): New.
+ (double_int::divmod_with_overflow): New.
+ * emit-rtl.c (init_emit_once): Change to new double_int API.
+ * explow.c (plus_constant): Likewise.
+ * expmed.c (choose_multiplier): Likewise.
+ * fold-const.c (#define OVERFLOW_SUM_SIGN): Remove.
+ (int_const_binop_1): Change to new double_int API.
+ (fold_div_compare): Likewise.
+ (maybe_canonicalize_comparison): Likewise.
+ (pointer_may_wrap_p): Likewise.
+ (fold_negate_const): Likewise.
+ (fold_abs_const): Likewise.
+ * simplify-rtx.c (simplify_const_unary_operation): Likewise.
+ (simplify_const_binary_operation): Likewise.
+ * tree-chrec.c (tree_fold_binomial): Likewise.
+ * tree-vrp.c (extract_range_from_binary_expr_1): Likewise.
+ * config/sparc/sparc.c (sparc_fold_builtin): Likewise.
+ * config/avr/avr.c (avr_double_int_push_digit): Likewise.
+ (avr_map): Likewise.
+ (avr_map_decompose): Likewise.
+ (avr_out_insert_bits): Likewise.
+
2012-09-24 Janis Johnson <janisjo@codesourcery.com>
doc/sourcebuild.texi (Selectors): Document the use of target
unsigned HOST_WIDE_INT digit)
{
val = 0 == base
- ? double_int_lshift (val, 32, 64, false)
- : double_int_mul (val, uhwi_to_double_int (base));
+ ? val.llshift (32, 64)
+ : val * double_int::from_uhwi (base);
- return double_int_add (val, uhwi_to_double_int (digit));
+ return val + double_int::from_uhwi (digit);
}
static int
avr_map (double_int f, int x)
{
- return 0xf & double_int_to_uhwi (double_int_rshift (f, 4*x, 64, false));
+ return 0xf & f.lrshift (4*x, 64).to_uhwi ();
}
are mapped to 0 and used operands are reloaded to xop[0]. */
xop[0] = all_regs_rtx[24];
- xop[1] = gen_int_mode (double_int_to_uhwi (f_ginv.map), SImode);
+ xop[1] = gen_int_mode (f_ginv.map.to_uhwi (), SImode);
xop[2] = all_regs_rtx[25];
xop[3] = val_used_p ? xop[0] : const0_rtx;
else if (flag_print_asm_name)
fprintf (asm_out_file,
ASM_COMMENT_START "map = 0x%08" HOST_LONG_FORMAT "x\n",
- double_int_to_uhwi (map) & GET_MODE_MASK (SImode));
+ map.to_uhwi () & GET_MODE_MASK (SImode));
/* If MAP has fixed points it might be better to initialize the result
with the bits to be inserted instead of moving all bits by hand. */
&& TREE_CODE (arg1) == VECTOR_CST
&& TREE_CODE (arg2) == INTEGER_CST)
{
- int overflow = 0;
- unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg2);
- HOST_WIDE_INT high = TREE_INT_CST_HIGH (arg2);
+ bool overflow = false;
+ double_int di_arg2 = TREE_INT_CST (arg2);
+ double_int tmp;
unsigned i;
for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
{
- unsigned HOST_WIDE_INT
- low0 = TREE_INT_CST_LOW (VECTOR_CST_ELT (arg0, i)),
- low1 = TREE_INT_CST_LOW (VECTOR_CST_ELT (arg1, i));
- HOST_WIDE_INT
- high0 = TREE_INT_CST_HIGH (VECTOR_CST_ELT (arg0, i));
- HOST_WIDE_INT
- high1 = TREE_INT_CST_HIGH (VECTOR_CST_ELT (arg1, i));
-
- unsigned HOST_WIDE_INT l;
- HOST_WIDE_INT h;
-
- overflow |= neg_double (low1, high1, &l, &h);
- overflow |= add_double (low0, high0, l, h, &l, &h);
- if (h < 0)
- overflow |= neg_double (l, h, &l, &h);
-
- overflow |= add_double (low, high, l, h, &low, &high);
+ double_int e0 = TREE_INT_CST (VECTOR_CST_ELT (arg0, i));
+ double_int e1 = TREE_INT_CST (VECTOR_CST_ELT (arg1, i));
+
+ bool neg1_ovf, neg2_ovf, add1_ovf, add2_ovf;
+
+ tmp = e1.neg_with_overflow (&neg1_ovf);
+ tmp = e0.add_with_sign (tmp, false, &add1_ovf);
+ if (tmp.is_negative ())
+ tmp = tmp.neg_with_overflow (&neg2_ovf);
+
+ tmp = di_arg2.add_with_sign (tmp, false, &add2_ovf);
+ overflow |= neg1_ovf | neg2_ovf | add1_ovf | add2_ovf;
}
- gcc_assert (overflow == 0);
+ gcc_assert (!overflow);
- return build_int_cst_wide (rtype, low, high);
+ return build_int_cst_wide (rtype, tmp.low, tmp.high);
}
default:
+2012-09-24 Lawrence Crowl <crowl@google.com>
+
+ * init.c (build_new_1): Change to new double_int API.
+ * decl.c (build_enumerator): Likewise.
+ * typeck2.c (process_init_constructor_array): Likewise.
+ * mangle.c (write_array_type): Likewise.
+
2012-09-24 Paolo Carlini <paolo.carlini@oracle.com>
PR c++/50828
{
if (TYPE_VALUES (enumtype))
{
- HOST_WIDE_INT hi;
- unsigned HOST_WIDE_INT lo;
tree prev_value;
bool overflowed;
value = error_mark_node;
else
{
- overflowed = add_double (TREE_INT_CST_LOW (prev_value),
- TREE_INT_CST_HIGH (prev_value),
- 1, 0, &lo, &hi);
+ double_int di = TREE_INT_CST (prev_value)
+ .add_with_sign (double_int_one,
+ false, &overflowed);
if (!overflowed)
{
- double_int di;
tree type = TREE_TYPE (prev_value);
- bool pos = (TYPE_UNSIGNED (type) || hi >= 0);
- di.low = lo; di.high = hi;
+ bool pos = TYPE_UNSIGNED (type) || !di.is_negative ();
if (!double_int_fits_to_tree_p (type, di))
{
unsigned int itk;
if (TREE_CONSTANT (inner_nelts_cst)
&& TREE_CODE (inner_nelts_cst) == INTEGER_CST)
{
- double_int result;
- if (mul_double (TREE_INT_CST_LOW (inner_nelts_cst),
- TREE_INT_CST_HIGH (inner_nelts_cst),
- inner_nelts_count.low, inner_nelts_count.high,
- &result.low, &result.high))
+ bool overflow;
+ double_int result = TREE_INT_CST (inner_nelts_cst)
+ .mul_with_sign (inner_nelts_count,
+ false, &overflow);
+ if (overflow)
{
if (complain & tf_error)
error ("integer overflow in array size");
/* Maximum available size in bytes. Half of the address space
minus the cookie size. */
double_int max_size
- = double_int_lshift (double_int_one, TYPE_PRECISION (sizetype) - 1,
- HOST_BITS_PER_DOUBLE_INT, false);
+ = double_int_one.llshift (TYPE_PRECISION (sizetype) - 1,
+ HOST_BITS_PER_DOUBLE_INT);
/* Size of the inner array elements. */
double_int inner_size;
/* Maximum number of outer elements which can be allocated. */
gcc_assert (TREE_CODE (size) == INTEGER_CST);
cookie_size = targetm.cxx.get_cookie_size (elt_type);
gcc_assert (TREE_CODE (cookie_size) == INTEGER_CST);
- gcc_checking_assert (double_int_ucmp
- (TREE_INT_CST (cookie_size), max_size) < 0);
+ gcc_checking_assert (TREE_INT_CST (cookie_size).ult (max_size));
/* Unconditionally substract the cookie size. This decreases the
maximum object size and is safe even if we choose not to use
a cookie after all. */
- max_size = double_int_sub (max_size, TREE_INT_CST (cookie_size));
- if (mul_double (TREE_INT_CST_LOW (size), TREE_INT_CST_HIGH (size),
- inner_nelts_count.low, inner_nelts_count.high,
- &inner_size.low, &inner_size.high)
- || double_int_ucmp (inner_size, max_size) > 0)
+ max_size -= TREE_INT_CST (cookie_size);
+ bool overflow;
+ inner_size = TREE_INT_CST (size)
+ .mul_with_sign (inner_nelts_count, false, &overflow);
+ if (overflow || inner_size.ugt (max_size))
{
if (complain & tf_error)
error ("size of array is too large");
return error_mark_node;
}
- max_outer_nelts = double_int_udiv (max_size, inner_size, TRUNC_DIV_EXPR);
+ max_outer_nelts = max_size.udiv (inner_size, TRUNC_DIV_EXPR);
/* Only keep the top-most seven bits, to simplify encoding the
constant in the instruction stream. */
{
- (max_outer_nelts.high ? clz_hwi (max_outer_nelts.high)
: (HOST_BITS_PER_WIDE_INT + clz_hwi (max_outer_nelts.low)));
max_outer_nelts
- = double_int_lshift (double_int_rshift
- (max_outer_nelts, shift,
- HOST_BITS_PER_DOUBLE_INT, false),
- shift, HOST_BITS_PER_DOUBLE_INT, false);
+ = max_outer_nelts.lrshift (shift, HOST_BITS_PER_DOUBLE_INT)
+ .llshift (shift, HOST_BITS_PER_DOUBLE_INT);
}
max_outer_nelts_tree = double_int_to_tree (sizetype, max_outer_nelts);
{
/* The ABI specifies that we should mangle the number of
elements in the array, not the largest allowed index. */
- double_int dmax
- = double_int_add (tree_to_double_int (max), double_int_one);
+ double_int dmax = tree_to_double_int (max) + double_int_one;
/* Truncate the result - this will mangle [0, SIZE_INT_MAX]
number of elements as zero. */
- dmax = double_int_zext (dmax, TYPE_PRECISION (TREE_TYPE (max)));
- gcc_assert (double_int_fits_in_uhwi_p (dmax));
+ dmax = dmax.zext (TYPE_PRECISION (TREE_TYPE (max)));
+ gcc_assert (dmax.fits_uhwi ());
write_unsigned_number (dmax.low);
}
else
{
tree domain = TYPE_DOMAIN (type);
if (domain)
- len = double_int_ext
- (double_int_add
- (double_int_sub
- (tree_to_double_int (TYPE_MAX_VALUE (domain)),
- tree_to_double_int (TYPE_MIN_VALUE (domain))),
- double_int_one),
- TYPE_PRECISION (TREE_TYPE (domain)),
- TYPE_UNSIGNED (TREE_TYPE (domain))).low;
+ len = (tree_to_double_int (TYPE_MAX_VALUE (domain))
+ - tree_to_double_int (TYPE_MIN_VALUE (domain))
+ + double_int_one)
+ .ext (TYPE_PRECISION (TREE_TYPE (domain)),
+ TYPE_UNSIGNED (TREE_TYPE (domain)))
+ .low;
else
unbounded = true; /* Take as many as there are. */
}
#include "tm.h" /* For SHIFT_COUNT_TRUNCATED. */
#include "tree.h"
+static int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
+ bool);
+
+#define add_double(l1,h1,l2,h2,lv,hv) \
+ add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
+
+static int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+
+static int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
+ bool);
+
+static int mul_double_wide_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
+ bool);
+
+#define mul_double(l1,h1,l2,h2,lv,hv) \
+ mul_double_with_sign (l1, h1, l2, h2, lv, hv, false)
+
+static void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, bool);
+
+static int div_and_round_double (unsigned, int, unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *);
+
/* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
and SUM1. Then this yields nonzero if overflow occurred during the
One argument is L1 and H1; the other, L2 and H2.
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
-int
+static int
add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
-int
+static int
neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
{
One argument is L1 and H1; the other, L2 and H2.
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
-int
+static int
mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
unsigned_p);
}
-int
+static int
mul_double_wide_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
-void
+static void
lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
HOST_WIDE_INT count, unsigned int prec,
unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, bool arith)
Return nonzero if the operation overflows.
UNS nonzero says do unsigned division. */
-int
+static int
div_and_round_double (unsigned code, int uns,
/* num == numerator == dividend */
unsigned HOST_WIDE_INT lnum_orig,
return ret;
}
+double_int
+double_int::wide_mul_with_sign (double_int b, bool unsigned_p,
+ double_int *higher, bool *overflow) const
+
+{
+ double_int lower;
+ *overflow = mul_double_wide_with_sign (low, high, b.low, b.high,
+ &lower.low, &lower.high,
+ &higher->low, &higher->high,
+ unsigned_p);
+ return lower;
+}
+
/* Returns A + B. */
double_int
return ret;
}
+/* Returns A - B. If the operation overflows via inconsistent sign bits,
+ *OVERFLOW is set to nonzero. */
+
+double_int
+double_int::sub_with_overflow (double_int b, bool *overflow) const
+{
+ double_int ret;
+ neg_double (b.low, b.high, &ret.low, &ret.high);
+ add_double (low, high, ret.low, ret.high, &ret.low, &ret.high);
+ *overflow = OVERFLOW_SUM_SIGN (ret.high, b.high, high);
+ return ret;
+}
+
/* Returns -A. */
double_int
return ret;
}
+double_int
+double_int::neg_with_overflow (bool *overflow) const
+{
+ double_int ret;
+ *overflow = neg_double (low, high, &ret.low, &ret.high);
+ return ret;
+}
+
/* Returns A / B (computed as unsigned depending on UNS, and rounded as
specified by CODE). CODE is enum tree_code in fact, but double_int.h
must be included before tree.h. The remainder after the division is
stored to MOD. */
+double_int
+double_int::divmod_with_overflow (double_int b, bool uns, unsigned code,
+ double_int *mod, bool *overflow) const
+{
+ const double_int &a = *this;
+ double_int ret;
+
+ *overflow = div_and_round_double (code, uns, a.low, a.high,
+ b.low, b.high, &ret.low, &ret.high,
+ &mod->low, &mod->high);
+ return ret;
+}
+
double_int
double_int::divmod (double_int b, bool uns, unsigned code,
double_int *mod) const
static double_int from_uhwi (unsigned HOST_WIDE_INT cst);
static double_int from_shwi (HOST_WIDE_INT cst);
+ static double_int from_pair (HOST_WIDE_INT high, unsigned HOST_WIDE_INT low);
/* No copy assignment operator or destructor to keep the type a POD. */
/* Arithmetic operation functions. */
+ /* The following operations perform arithmetics modulo 2^precision, so you
+ do not need to call .ext between them, even if you are representing
+ numbers with precision less than HOST_BITS_PER_DOUBLE_INT bits. */
+
double_int set_bit (unsigned) const;
double_int mul_with_sign (double_int, bool unsigned_p, bool *overflow) const;
+ double_int wide_mul_with_sign (double_int, bool unsigned_p,
+ double_int *higher, bool *overflow) const;
double_int add_with_sign (double_int, bool unsigned_p, bool *overflow) const;
+ double_int sub_with_overflow (double_int, bool *overflow) const;
+ double_int neg_with_overflow (bool *overflow) const;
double_int operator * (double_int) const;
double_int operator + (double_int) const;
/* You must ensure that double_int::ext is called on the operands
of the following operations, if the precision of the numbers
is less than HOST_BITS_PER_DOUBLE_INT bits. */
+
double_int div (double_int, bool, unsigned) const;
double_int sdiv (double_int, unsigned) const;
double_int udiv (double_int, unsigned) const;
double_int mod (double_int, bool, unsigned) const;
double_int smod (double_int, unsigned) const;
double_int umod (double_int, unsigned) const;
+ double_int divmod_with_overflow (double_int, bool, unsigned,
+ double_int *, bool *) const;
double_int divmod (double_int, bool, unsigned, double_int *) const;
double_int sdivmod (double_int, unsigned, double_int *) const;
double_int udivmod (double_int, unsigned, double_int *) const;
return r;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-shwi_to_double_int (HOST_WIDE_INT cst)
-{
- return double_int::from_shwi (cst);
-}
-
/* Some useful constants. */
/* FIXME(crowl): Maybe remove after converting callers?
The problem is that a named constant would not be as optimizable,
return r;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-uhwi_to_double_int (unsigned HOST_WIDE_INT cst)
+inline double_int
+double_int::from_pair (HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
{
- return double_int::from_uhwi (cst);
+ double_int r;
+ r.low = low;
+ r.high = high;
+ return r;
}
inline double_int &
return (HOST_WIDE_INT) low;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline HOST_WIDE_INT
-double_int_to_shwi (double_int cst)
-{
- return cst.to_shwi ();
-}
-
/* Returns value of CST as an unsigned number. CST must satisfy
double_int::fits_unsigned. */
return low;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline unsigned HOST_WIDE_INT
-double_int_to_uhwi (double_int cst)
-{
- return cst.to_uhwi ();
-}
-
/* Returns true if CST fits in unsigned HOST_WIDE_INT. */
inline bool
return high == 0;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline bool
-double_int_fits_in_uhwi_p (double_int cst)
-{
- return cst.fits_uhwi ();
-}
-
-/* Returns true if CST fits in signed HOST_WIDE_INT. */
-
-/* FIXME(crowl): Remove after converting callers. */
-inline bool
-double_int_fits_in_shwi_p (double_int cst)
-{
- return cst.fits_shwi ();
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline bool
-double_int_fits_in_hwi_p (double_int cst, bool uns)
-{
- return cst.fits_hwi (uns);
-}
-
-/* The following operations perform arithmetics modulo 2^precision,
- so you do not need to call double_int_ext between them, even if
- you are representing numbers with precision less than
- HOST_BITS_PER_DOUBLE_INT bits. */
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_mul (double_int a, double_int b)
-{
- return a * b;
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_mul_with_sign (double_int a, double_int b,
- bool unsigned_p, int *overflow)
-{
- bool ovf;
- return a.mul_with_sign (b, unsigned_p, &ovf);
- *overflow = ovf;
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_add (double_int a, double_int b)
-{
- return a + b;
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_sub (double_int a, double_int b)
-{
- return a - b;
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_neg (double_int a)
-{
- return -a;
-}
-
-/* You must ensure that double_int_ext is called on the operands
- of the following operations, if the precision of the numbers
- is less than HOST_BITS_PER_DOUBLE_INT bits. */
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_div (double_int a, double_int b, bool uns, unsigned code)
-{
- return a.div (b, uns, code);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_sdiv (double_int a, double_int b, unsigned code)
-{
- return a.sdiv (b, code);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_udiv (double_int a, double_int b, unsigned code)
-{
- return a.udiv (b, code);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_mod (double_int a, double_int b, bool uns, unsigned code)
-{
- return a.mod (b, uns, code);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_smod (double_int a, double_int b, unsigned code)
-{
- return a.smod (b, code);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_umod (double_int a, double_int b, unsigned code)
-{
- return a.umod (b, code);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_divmod (double_int a, double_int b, bool uns,
- unsigned code, double_int *mod)
-{
- return a.divmod (b, uns, code, mod);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_sdivmod (double_int a, double_int b, unsigned code, double_int *mod)
-{
- return a.sdivmod (b, code, mod);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_udivmod (double_int a, double_int b, unsigned code, double_int *mod)
-{
- return a.udivmod (b, code, mod);
-}
-
-/***/
-
-/* FIXME(crowl): Remove after converting callers. */
-inline bool
-double_int_multiple_of (double_int product, double_int factor,
- bool unsigned_p, double_int *multiple)
-{
- return product.multiple_of (factor, unsigned_p, multiple);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_setbit (double_int a, unsigned bitpos)
-{
- return a.set_bit (bitpos);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline int
-double_int_ctz (double_int a)
-{
- return a.trailing_zeros ();
-}
-
/* Logical operations. */
/* Returns ~A. */
return result;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-double_int_not (double_int a)
-{
- return ~a;
-}
-
/* Returns A | B. */
inline double_int
return result;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-double_int_ior (double_int a, double_int b)
-{
- return a | b;
-}
-
/* Returns A & B. */
inline double_int
return result;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-double_int_and (double_int a, double_int b)
-{
- return a & b;
-}
-
/* Returns A & ~B. */
inline double_int
return result;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-double_int_and_not (double_int a, double_int b)
-{
- return a.and_not (b);
-}
-
/* Returns A ^ B. */
inline double_int
return result;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline double_int
-double_int_xor (double_int a, double_int b)
-{
- return a ^ b;
-}
-
-
-/* Shift operations. */
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_lshift (double_int a, HOST_WIDE_INT count, unsigned int prec,
- bool arith)
-{
- return a.lshift (count, prec, arith);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_rshift (double_int a, HOST_WIDE_INT count, unsigned int prec,
- bool arith)
-{
- return a.rshift (count, prec, arith);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_lrotate (double_int a, HOST_WIDE_INT count, unsigned int prec)
-{
- return a.lrotate (count, prec);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_rrotate (double_int a, HOST_WIDE_INT count, unsigned int prec)
-{
- return a.rrotate (count, prec);
-}
-
-/* Returns true if CST is negative. Of course, CST is considered to
- be signed. */
-
-static inline bool
-double_int_negative_p (double_int cst)
-{
- return cst.high < 0;
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline int
-double_int_cmp (double_int a, double_int b, bool uns)
-{
- return a.cmp (b, uns);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline int
-double_int_scmp (double_int a, double_int b)
-{
- return a.scmp (b);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline int
-double_int_ucmp (double_int a, double_int b)
-{
- return a.ucmp (b);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_max (double_int a, double_int b, bool uns)
-{
- return a.max (b, uns);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_smax (double_int a, double_int b)
-{
- return a.smax (b);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_umax (double_int a, double_int b)
-{
- return a.umax (b);
-}
-
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_min (double_int a, double_int b, bool uns)
-{
- return a.min (b, uns);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_smin (double_int a, double_int b)
-{
- return a.smin (b);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_umin (double_int a, double_int b)
-{
- return a.umin (b);
-}
-
void dump_double_int (FILE *, double_int, bool);
-/* Zero and sign extension of numbers in smaller precisions. */
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_ext (double_int a, unsigned prec, bool uns)
-{
- return a.ext (prec, uns);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_sext (double_int a, unsigned prec)
-{
- return a.sext (prec);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_zext (double_int a, unsigned prec)
-{
- return a.zext (prec);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_mask (unsigned prec)
-{
- return double_int::mask (prec);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_max_value (unsigned int prec, bool uns)
-{
- return double_int::max_value (prec, uns);
-}
-
-/* FIXME(crowl): Remove after converting callers. */
-inline double_int
-double_int_min_value (unsigned int prec, bool uns)
-{
- return double_int::min_value (prec, uns);
-}
-
#define ALL_ONES (~((unsigned HOST_WIDE_INT) 0))
/* The operands of the following comparison functions must be processed
return low == 0 && high == 0;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline bool
-double_int_zero_p (double_int cst)
-{
- return cst.is_zero ();
-}
-
/* Returns true if CST is one. */
inline bool
return low == 1 && high == 0;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline bool
-double_int_one_p (double_int cst)
-{
- return cst.is_one ();
-}
-
/* Returns true if CST is minus one. */
inline bool
return low == ALL_ONES && high == -1;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline bool
-double_int_minus_one_p (double_int cst)
-{
- return cst.is_minus_one ();
-}
-
/* Returns true if CST is negative. */
inline bool
return low == cst2.low && high == cst2.high;
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline bool
-double_int_equal_p (double_int cst1, double_int cst2)
-{
- return cst1 == cst2;
-}
-
/* Returns true if CST1 != CST2. */
inline bool
return popcount_hwi (high) + popcount_hwi (low);
}
-/* FIXME(crowl): Remove after converting callers. */
-static inline int
-double_int_popcount (double_int cst)
-{
- return cst.popcount ();
-}
-
-
-/* Legacy interface with decomposed high/low parts. */
-
-/* FIXME(crowl): Remove after converting callers. */
-extern int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
- bool);
-/* FIXME(crowl): Remove after converting callers. */
-#define add_double(l1,h1,l2,h2,lv,hv) \
- add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
-/* FIXME(crowl): Remove after converting callers. */
-extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
-/* FIXME(crowl): Remove after converting callers. */
-extern int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
- bool);
-/* FIXME(crowl): Remove after converting callers. */
-extern int mul_double_wide_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
- unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
- bool);
-/* FIXME(crowl): Remove after converting callers. */
-#define mul_double(l1,h1,l2,h2,lv,hv) \
- mul_double_with_sign (l1, h1, l2, h2, lv, hv, false)
-/* FIXME(crowl): Remove after converting callers. */
-extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, bool);
-/* FIXME(crowl): Remove after converting callers. */
-extern int div_and_round_double (unsigned, int, unsigned HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *);
-
#ifndef GENERATOR_FILE
/* Conversion to and from GMP integer representations. */
FCONST1(mode).data.high = 0;
FCONST1(mode).data.low = 0;
FCONST1(mode).mode = mode;
- lshift_double (1, 0, GET_MODE_FBIT (mode),
- HOST_BITS_PER_DOUBLE_INT,
- &FCONST1(mode).data.low,
- &FCONST1(mode).data.high,
- SIGNED_FIXED_POINT_MODE_P (mode));
+ FCONST1(mode).data
+ = double_int_one.lshift (GET_MODE_FBIT (mode),
+ HOST_BITS_PER_DOUBLE_INT,
+ SIGNED_FIXED_POINT_MODE_P (mode));
const_tiny_rtx[1][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST1 (mode), mode);
}
FCONST1(mode).data.high = 0;
FCONST1(mode).data.low = 0;
FCONST1(mode).mode = mode;
- lshift_double (1, 0, GET_MODE_FBIT (mode),
- HOST_BITS_PER_DOUBLE_INT,
- &FCONST1(mode).data.low,
- &FCONST1(mode).data.high,
- SIGNED_FIXED_POINT_MODE_P (mode));
+ FCONST1(mode).data
+ = double_int_one.lshift (GET_MODE_FBIT (mode),
+ HOST_BITS_PER_DOUBLE_INT,
+ SIGNED_FIXED_POINT_MODE_P (mode));
const_tiny_rtx[1][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST1 (mode), mode);
}
case CONST_INT:
if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
{
- unsigned HOST_WIDE_INT l1 = INTVAL (x);
- HOST_WIDE_INT h1 = (l1 >> (HOST_BITS_PER_WIDE_INT - 1)) ? -1 : 0;
- unsigned HOST_WIDE_INT l2 = c;
- HOST_WIDE_INT h2 = c < 0 ? -1 : 0;
- unsigned HOST_WIDE_INT lv;
- HOST_WIDE_INT hv;
-
- if (add_double_with_sign (l1, h1, l2, h2, &lv, &hv, false))
+ double_int di_x = double_int::from_shwi (INTVAL (x));
+ double_int di_c = double_int::from_shwi (c);
+
+ bool overflow;
+ double_int v = di_x.add_with_sign (di_c, false, &overflow);
+ if (overflow)
gcc_unreachable ();
- return immed_double_const (lv, hv, VOIDmode);
+ return immed_double_int_const (v, VOIDmode);
}
return GEN_INT (INTVAL (x) + c);
case CONST_DOUBLE:
{
- unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
- HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
- unsigned HOST_WIDE_INT l2 = c;
- HOST_WIDE_INT h2 = c < 0 ? -1 : 0;
- unsigned HOST_WIDE_INT lv;
- HOST_WIDE_INT hv;
-
- if (add_double_with_sign (l1, h1, l2, h2, &lv, &hv, false))
+ double_int di_x = double_int::from_pair (CONST_DOUBLE_HIGH (x),
+ CONST_DOUBLE_LOW (x));
+ double_int di_c = double_int::from_shwi (c);
+
+ bool overflow;
+ double_int v = di_x.add_with_sign (di_c, false, &overflow);
+ if (overflow)
/* Sorry, we have no way to represent overflows this wide.
To fix, add constant support wider than CONST_DOUBLE. */
gcc_assert (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_DOUBLE_INT);
- return immed_double_const (lv, hv, VOIDmode);
+ return immed_double_int_const (v, VOIDmode);
}
case MEM:
unsigned HOST_WIDE_INT *multiplier_ptr,
int *post_shift_ptr, int *lgup_ptr)
{
- HOST_WIDE_INT mhigh_hi, mlow_hi;
- unsigned HOST_WIDE_INT mhigh_lo, mlow_lo;
+ double_int mhigh, mlow;
int lgup, post_shift;
int pow, pow2;
- unsigned HOST_WIDE_INT nl, dummy1;
- HOST_WIDE_INT nh, dummy2;
/* lgup = ceil(log2(divisor)); */
lgup = ceil_log2 (d);
gcc_assert (pow != HOST_BITS_PER_DOUBLE_INT);
/* mlow = 2^(N + lgup)/d */
- if (pow >= HOST_BITS_PER_WIDE_INT)
- {
- nh = (HOST_WIDE_INT) 1 << (pow - HOST_BITS_PER_WIDE_INT);
- nl = 0;
- }
- else
- {
- nh = 0;
- nl = (unsigned HOST_WIDE_INT) 1 << pow;
- }
- div_and_round_double (TRUNC_DIV_EXPR, 1, nl, nh, d, (HOST_WIDE_INT) 0,
- &mlow_lo, &mlow_hi, &dummy1, &dummy2);
+ double_int val = double_int_zero.set_bit (pow);
+ mlow = val.div (double_int::from_uhwi (d), true, TRUNC_DIV_EXPR);
- /* mhigh = (2^(N + lgup) + 2^N + lgup - precision)/d */
- if (pow2 >= HOST_BITS_PER_WIDE_INT)
- nh |= (HOST_WIDE_INT) 1 << (pow2 - HOST_BITS_PER_WIDE_INT);
- else
- nl |= (unsigned HOST_WIDE_INT) 1 << pow2;
- div_and_round_double (TRUNC_DIV_EXPR, 1, nl, nh, d, (HOST_WIDE_INT) 0,
- &mhigh_lo, &mhigh_hi, &dummy1, &dummy2);
+ /* mhigh = (2^(N + lgup) + 2^(N + lgup - precision))/d */
+ val |= double_int_zero.set_bit (pow2);
+ mhigh = val.div (double_int::from_uhwi (d), true, TRUNC_DIV_EXPR);
- gcc_assert (!mhigh_hi || nh - d < d);
- gcc_assert (mhigh_hi <= 1 && mlow_hi <= 1);
+ gcc_assert (!mhigh.high || val.high - d < d);
+ gcc_assert (mhigh.high <= 1 && mlow.high <= 1);
/* Assert that mlow < mhigh. */
- gcc_assert (mlow_hi < mhigh_hi
- || (mlow_hi == mhigh_hi && mlow_lo < mhigh_lo));
+ gcc_assert (mlow.ult (mhigh));
/* If precision == N, then mlow, mhigh exceed 2^N
(but they do not exceed 2^(N+1)). */
/* Reduce to lowest terms. */
for (post_shift = lgup; post_shift > 0; post_shift--)
{
- unsigned HOST_WIDE_INT ml_lo = (mlow_hi << (HOST_BITS_PER_WIDE_INT - 1)) | (mlow_lo >> 1);
- unsigned HOST_WIDE_INT mh_lo = (mhigh_hi << (HOST_BITS_PER_WIDE_INT - 1)) | (mhigh_lo >> 1);
+ int shft = HOST_BITS_PER_WIDE_INT - 1;
+ unsigned HOST_WIDE_INT ml_lo = (mlow.high << shft) | (mlow.low >> 1);
+ unsigned HOST_WIDE_INT mh_lo = (mhigh.high << shft) | (mhigh.low >> 1);
if (ml_lo >= mh_lo)
break;
- mlow_hi = 0;
- mlow_lo = ml_lo;
- mhigh_hi = 0;
- mhigh_lo = mh_lo;
+ mlow = double_int::from_uhwi (ml_lo);
+ mhigh = double_int::from_uhwi (mh_lo);
}
*post_shift_ptr = post_shift;
if (n < HOST_BITS_PER_WIDE_INT)
{
unsigned HOST_WIDE_INT mask = ((unsigned HOST_WIDE_INT) 1 << n) - 1;
- *multiplier_ptr = mhigh_lo & mask;
- return mhigh_lo >= mask;
+ *multiplier_ptr = mhigh.low & mask;
+ return mhigh.low >= mask;
}
else
{
- *multiplier_ptr = mhigh_lo;
- return mhigh_hi;
+ *multiplier_ptr = mhigh.low;
+ return mhigh.high;
}
}
}
return x;
}
-
-
-/* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
- overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
- and SUM1. Then this yields nonzero if overflow occurred during the
- addition.
-
- Overflow occurs if A and B have the same sign, but A and SUM differ in
- sign. Use `^' to test whether signs differ, and `< 0' to isolate the
- sign. */
-#define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
\f
/* If ARG2 divides ARG1 with zero remainder, carries out the division
of type CODE and returns the quotient.
break;
case MINUS_EXPR:
-/* FIXME(crowl) Remove this code if the replacment works.
- neg_double (op2.low, op2.high, &res.low, &res.high);
- add_double (op1.low, op1.high, res.low, res.high,
- &res.low, &res.high);
- overflow = OVERFLOW_SUM_SIGN (res.high, op2.high, op1.high);
-*/
- res = op1.add_with_sign (-op2, false, &overflow);
+ res = op1.sub_with_overflow (op2, &overflow);
break;
case MULT_EXPR:
res = double_int_one;
break;
}
- overflow = div_and_round_double (code, uns,
- op1.low, op1.high, op2.low, op2.high,
- &res.low, &res.high,
- &tmp.low, &tmp.high);
+ res = op1.divmod_with_overflow (op2, uns, code, &tmp, &overflow);
break;
case TRUNC_MOD_EXPR:
case ROUND_MOD_EXPR:
if (op2.is_zero ())
return NULL_TREE;
- overflow = div_and_round_double (code, uns,
- op1.low, op1.high, op2.low, op2.high,
- &tmp.low, &tmp.high,
- &res.low, &res.high);
+ tmp = op1.divmod_with_overflow (op2, uns, code, &res, &overflow);
break;
case MIN_EXPR:
double_int val;
bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
bool neg_overflow;
- int overflow;
+ bool overflow;
/* We have to do this the hard way to detect unsigned overflow.
prod = int_const_binop (MULT_EXPR, arg01, arg1); */
- overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
- TREE_INT_CST_HIGH (arg01),
- TREE_INT_CST_LOW (arg1),
- TREE_INT_CST_HIGH (arg1),
- &val.low, &val.high, unsigned_p);
+ val = TREE_INT_CST (arg01)
+ .mul_with_sign (TREE_INT_CST (arg1), unsigned_p, &overflow);
prod = force_fit_type_double (TREE_TYPE (arg00), val, -1, overflow);
neg_overflow = false;
lo = prod;
/* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
- overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
- TREE_INT_CST_HIGH (prod),
- TREE_INT_CST_LOW (tmp),
- TREE_INT_CST_HIGH (tmp),
- &val.low, &val.high, unsigned_p);
+ val = TREE_INT_CST (prod)
+ .add_with_sign (TREE_INT_CST (tmp), unsigned_p, &overflow);
hi = force_fit_type_double (TREE_TYPE (arg00), val,
-1, overflow | TREE_OVERFLOW (prod));
}
static bool
pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
{
- unsigned HOST_WIDE_INT offset_low, total_low;
- HOST_WIDE_INT size, offset_high, total_high;
+ double_int di_offset, total;
if (!POINTER_TYPE_P (TREE_TYPE (base)))
return true;
return true;
if (offset == NULL_TREE)
- {
- offset_low = 0;
- offset_high = 0;
- }
+ di_offset = double_int_zero;
else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
return true;
else
- {
- offset_low = TREE_INT_CST_LOW (offset);
- offset_high = TREE_INT_CST_HIGH (offset);
- }
+ di_offset = TREE_INT_CST (offset);
- if (add_double_with_sign (offset_low, offset_high,
- bitpos / BITS_PER_UNIT, 0,
- &total_low, &total_high,
- true))
+ bool overflow;
+ double_int units = double_int::from_uhwi (bitpos / BITS_PER_UNIT);
+ total = di_offset.add_with_sign (units, true, &overflow);
+ if (overflow)
return true;
- if (total_high != 0)
+ if (total.high != 0)
return true;
- size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
+ HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
if (size <= 0)
return true;
size = base_size;
}
- return total_low > (unsigned HOST_WIDE_INT) size;
+ return total.low > (unsigned HOST_WIDE_INT) size;
}
/* Subroutine of fold_binary. This routine performs all of the
case INTEGER_CST:
{
double_int val = tree_to_double_int (arg0);
- int overflow = neg_double (val.low, val.high, &val.low, &val.high);
-
+ bool overflow;
+ val = val.neg_with_overflow (&overflow);
t = force_fit_type_double (type, val, 1,
(overflow | TREE_OVERFLOW (arg0))
&& !TYPE_UNSIGNED (type));
its negation. */
else
{
- int overflow;
-
- overflow = neg_double (val.low, val.high, &val.low, &val.high);
+ bool overflow;
+ val = val.neg_with_overflow (&overflow);
t = force_fit_type_double (type, val, -1,
overflow | TREE_OVERFLOW (arg0));
}
+2012-09-24 Lawrence Crowl <crowl@google.com>
+
+ * trans-expr.c (gfc_conv_cst_int_power): Change to new double_int API.
+ * target-memory.c (gfc_interpret_logical): Likewise.
+
2012-09-23 Tobias Burnus <burnus@net-b.de>
* parse.c (parse_derived): Don't set attr.alloc_comp
{
tree t = native_interpret_expr (gfc_get_logical_type (kind), buffer,
buffer_size);
- *logical = double_int_zero_p (tree_to_double_int (t))
- ? 0 : 1;
+ *logical = tree_to_double_int (t).is_zero () ? 0 : 1;
return size_logical (kind);
}
/* If exponent is too large, we won't expand it anyway, so don't bother
with large integer values. */
- if (!double_int_fits_in_shwi_p (TREE_INT_CST (rhs)))
+ if (!TREE_INT_CST (rhs).fits_shwi ())
return 0;
- m = double_int_to_shwi (TREE_INT_CST (rhs));
+ m = TREE_INT_CST (rhs).to_shwi ();
/* There's no ABS for HOST_WIDE_INT, so here we go. It also takes care
of the asymmetric range of the integer type. */
n = (unsigned HOST_WIDE_INT) (m < 0 ? -m : m);
+2012-09-24 Lawrence Crowl <crowl@google.com>
+
+ * decl.c (java_init_decl_processing): Change to new double_int API.
+ * jcf-parse.c (get_constant): Likewise.
+ * boehm.c (mark_reference_fields): Likewise.
+ (get_boehm_type_descriptor): Likewise.
+
2012-07-30 Laurynas Biveinis <laurynas.biveinis@gmail.com>
* jcf.h (CPool): Use the "atomic" GTY option for the tags field.
bits for all words in the record. This is conservative, but the
size_words != 1 case is impossible in regular java code. */
for (i = 0; i < size_words; ++i)
- *mask = double_int_setbit (*mask, ubit - count - i - 1);
+ *mask = (*mask).set_bit (ubit - count - i - 1);
if (count >= ubit - 2)
*pointer_after_end = 1;
while (last_set_index)
{
if ((last_set_index & 1))
- mask = double_int_setbit (mask, log2_size + count);
+ mask = mask.set_bit (log2_size + count);
last_set_index >>= 1;
++count;
}
else if (! pointer_after_end)
{
/* Bottom two bits for bitmap mark type are 01. */
- mask = double_int_setbit (mask, 0);
+ mask = mask.set_bit (0);
value = double_int_to_tree (value_type, mask);
}
else
decimal_int_max = build_int_cstu (unsigned_int_type_node, 0x80000000);
decimal_long_max
= double_int_to_tree (unsigned_long_type_node,
- double_int_setbit (double_int_zero, 64));
+ double_int_zero.set_bit (64));
long_zero_node = build_int_cst (long_type_node, 0);
double_int val;
num = JPOOL_UINT (jcf, index);
- val = double_int_lshift (uhwi_to_double_int (num), 32, 64, false);
+ val = double_int::from_uhwi (num).llshift (32, 64);
num = JPOOL_UINT (jcf, index + 1);
- val = double_int_ior (val, uhwi_to_double_int (num));
+ val |= double_int::from_uhwi (num);
value = double_int_to_tree (long_type_node, val);
break;
else if (width <= HOST_BITS_PER_DOUBLE_INT
&& (CONST_DOUBLE_AS_INT_P (op) || CONST_INT_P (op)))
{
- unsigned HOST_WIDE_INT l1, lv;
- HOST_WIDE_INT h1, hv;
+ double_int first, value;
if (CONST_DOUBLE_AS_INT_P (op))
- l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
+ first = double_int::from_pair (CONST_DOUBLE_HIGH (op),
+ CONST_DOUBLE_LOW (op));
else
- l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1);
+ first = double_int::from_shwi (INTVAL (op));
switch (code)
{
case NOT:
- lv = ~ l1;
- hv = ~ h1;
+ value = ~first;
break;
case NEG:
- neg_double (l1, h1, &lv, &hv);
+ value = -first;
break;
case ABS:
- if (h1 < 0)
- neg_double (l1, h1, &lv, &hv);
+ if (first.is_negative ())
+ value = -first;
else
- lv = l1, hv = h1;
+ value = first;
break;
case FFS:
- hv = 0;
- if (l1 != 0)
- lv = ffs_hwi (l1);
- else if (h1 != 0)
- lv = HOST_BITS_PER_WIDE_INT + ffs_hwi (h1);
+ value.high = 0;
+ if (first.low != 0)
+ value.low = ffs_hwi (first.low);
+ else if (first.high != 0)
+ value.low = HOST_BITS_PER_WIDE_INT + ffs_hwi (first.high);
else
- lv = 0;
+ value.low = 0;
break;
case CLZ:
- hv = 0;
- if (h1 != 0)
- lv = GET_MODE_PRECISION (mode) - floor_log2 (h1) - 1
- - HOST_BITS_PER_WIDE_INT;
- else if (l1 != 0)
- lv = GET_MODE_PRECISION (mode) - floor_log2 (l1) - 1;
- else if (! CLZ_DEFINED_VALUE_AT_ZERO (mode, lv))
- lv = GET_MODE_PRECISION (mode);
+ value.high = 0;
+ if (first.high != 0)
+ value.low = GET_MODE_PRECISION (mode) - floor_log2 (first.high) - 1
+ - HOST_BITS_PER_WIDE_INT;
+ else if (first.low != 0)
+ value.low = GET_MODE_PRECISION (mode) - floor_log2 (first.low) - 1;
+ else if (! CLZ_DEFINED_VALUE_AT_ZERO (mode, value.low))
+ value.low = GET_MODE_PRECISION (mode);
break;
case CTZ:
- hv = 0;
- if (l1 != 0)
- lv = ctz_hwi (l1);
- else if (h1 != 0)
- lv = HOST_BITS_PER_WIDE_INT + ctz_hwi (h1);
- else if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, lv))
- lv = GET_MODE_PRECISION (mode);
+ value.high = 0;
+ if (first.low != 0)
+ value.low = ctz_hwi (first.low);
+ else if (first.high != 0)
+ value.low = HOST_BITS_PER_WIDE_INT + ctz_hwi (first.high);
+ else if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, value.low))
+ value.low = GET_MODE_PRECISION (mode);
break;
case POPCOUNT:
- hv = 0;
- lv = 0;
- while (l1)
- lv++, l1 &= l1 - 1;
- while (h1)
- lv++, h1 &= h1 - 1;
+ value = double_int_zero;
+ while (first.low)
+ {
+ value.low++;
+ first.low &= first.low - 1;
+ }
+ while (first.high)
+ {
+ value.low++;
+ first.high &= first.high - 1;
+ }
break;
case PARITY:
- hv = 0;
- lv = 0;
- while (l1)
- lv++, l1 &= l1 - 1;
- while (h1)
- lv++, h1 &= h1 - 1;
- lv &= 1;
+ value = double_int_zero;
+ while (first.low)
+ {
+ value.low++;
+ first.low &= first.low - 1;
+ }
+ while (first.high)
+ {
+ value.low++;
+ first.high &= first.high - 1;
+ }
+ value.low &= 1;
break;
case BSWAP:
{
unsigned int s;
- hv = 0;
- lv = 0;
+ value = double_int_zero;
for (s = 0; s < width; s += 8)
{
unsigned int d = width - s - 8;
unsigned HOST_WIDE_INT byte;
if (s < HOST_BITS_PER_WIDE_INT)
- byte = (l1 >> s) & 0xff;
+ byte = (first.low >> s) & 0xff;
else
- byte = (h1 >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
+ byte = (first.high >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
if (d < HOST_BITS_PER_WIDE_INT)
- lv |= byte << d;
+ value.low |= byte << d;
else
- hv |= byte << (d - HOST_BITS_PER_WIDE_INT);
+ value.high |= byte << (d - HOST_BITS_PER_WIDE_INT);
}
}
break;
case TRUNCATE:
/* This is just a change-of-mode, so do nothing. */
- lv = l1, hv = h1;
+ value = first;
break;
case ZERO_EXTEND:
if (op_width > HOST_BITS_PER_WIDE_INT)
return 0;
- hv = 0;
- lv = l1 & GET_MODE_MASK (op_mode);
+ value = double_int::from_uhwi (first.low & GET_MODE_MASK (op_mode));
break;
case SIGN_EXTEND:
return 0;
else
{
- lv = l1 & GET_MODE_MASK (op_mode);
- if (val_signbit_known_set_p (op_mode, lv))
- lv |= ~GET_MODE_MASK (op_mode);
+ value.low = first.low & GET_MODE_MASK (op_mode);
+ if (val_signbit_known_set_p (op_mode, value.low))
+ value.low |= ~GET_MODE_MASK (op_mode);
- hv = HWI_SIGN_EXTEND (lv);
+ value.high = HWI_SIGN_EXTEND (value.low);
}
break;
return 0;
}
- return immed_double_const (lv, hv, mode);
+ return immed_double_int_const (value, mode);
}
else if (CONST_DOUBLE_AS_FLOAT_P (op)
&& (CONST_DOUBLE_AS_INT_P (op1) || CONST_INT_P (op1)))
{
double_int o0, o1, res, tmp;
+ bool overflow;
o0 = rtx_to_double_int (op0);
o1 = rtx_to_double_int (op1);
break;
case DIV:
- if (div_and_round_double (TRUNC_DIV_EXPR, 0,
- o0.low, o0.high, o1.low, o1.high,
- &res.low, &res.high,
- &tmp.low, &tmp.high))
+ res = o0.divmod_with_overflow (o1, false, TRUNC_DIV_EXPR,
+ &tmp, &overflow);
+ if (overflow)
return 0;
break;
case MOD:
- if (div_and_round_double (TRUNC_DIV_EXPR, 0,
- o0.low, o0.high, o1.low, o1.high,
- &tmp.low, &tmp.high,
- &res.low, &res.high))
+ tmp = o0.divmod_with_overflow (o1, false, TRUNC_DIV_EXPR,
+ &res, &overflow);
+ if (overflow)
return 0;
break;
case UDIV:
- if (div_and_round_double (TRUNC_DIV_EXPR, 1,
- o0.low, o0.high, o1.low, o1.high,
- &res.low, &res.high,
- &tmp.low, &tmp.high))
+ res = o0.divmod_with_overflow (o1, true, TRUNC_DIV_EXPR,
+ &tmp, &overflow);
+ if (overflow)
return 0;
break;
case UMOD:
- if (div_and_round_double (TRUNC_DIV_EXPR, 1,
- o0.low, o0.high, o1.low, o1.high,
- &tmp.low, &tmp.high,
- &res.low, &res.high))
+ tmp = o0.divmod_with_overflow (o1, true, TRUNC_DIV_EXPR,
+ &res, &overflow);
+ if (overflow)
return 0;
break;
static tree
tree_fold_binomial (tree type, tree n, unsigned int k)
{
- unsigned HOST_WIDE_INT lidx, lnum, ldenom, lres, ldum;
- HOST_WIDE_INT hidx, hnum, hdenom, hres, hdum;
+ double_int num, denom, idx, di_res;
+ bool overflow;
unsigned int i;
tree res;
if (k == 1)
return fold_convert (type, n);
+ /* Numerator = n. */
+ num = TREE_INT_CST (n);
+
/* Check that k <= n. */
- if (TREE_INT_CST_HIGH (n) == 0
- && TREE_INT_CST_LOW (n) < k)
+ if (num.ult (double_int::from_uhwi (k)))
return NULL_TREE;
- /* Numerator = n. */
- lnum = TREE_INT_CST_LOW (n);
- hnum = TREE_INT_CST_HIGH (n);
-
/* Denominator = 2. */
- ldenom = 2;
- hdenom = 0;
+ denom = double_int::from_uhwi (2);
/* Index = Numerator-1. */
- if (lnum == 0)
- {
- hidx = hnum - 1;
- lidx = ~ (unsigned HOST_WIDE_INT) 0;
- }
- else
- {
- hidx = hnum;
- lidx = lnum - 1;
- }
+ idx = num - double_int_one;
/* Numerator = Numerator*Index = n*(n-1). */
- if (mul_double (lnum, hnum, lidx, hidx, &lnum, &hnum))
+ num = num.mul_with_sign (idx, false, &overflow);
+ if (overflow)
return NULL_TREE;
for (i = 3; i <= k; i++)
{
/* Index--. */
- if (lidx == 0)
- {
- hidx--;
- lidx = ~ (unsigned HOST_WIDE_INT) 0;
- }
- else
- lidx--;
+ --idx;
/* Numerator *= Index. */
- if (mul_double (lnum, hnum, lidx, hidx, &lnum, &hnum))
+ num = num.mul_with_sign (idx, false, &overflow);
+ if (overflow)
return NULL_TREE;
/* Denominator *= i. */
- mul_double (ldenom, hdenom, i, 0, &ldenom, &hdenom);
+ denom *= double_int::from_uhwi (i);
}
/* Result = Numerator / Denominator. */
- div_and_round_double (EXACT_DIV_EXPR, 1, lnum, hnum, ldenom, hdenom,
- &lres, &hres, &ldum, &hdum);
-
- res = build_int_cst_wide (type, lres, hres);
+ di_res = num.div (denom, true, EXACT_DIV_EXPR);
+ res = build_int_cst_wide (type, di_res.low, di_res.high);
return int_fits_type_p (res, type) ? res : NULL_TREE;
}
if (tmin.cmp (tmax, uns) < 0)
covers = true;
tmax = tem + double_int_minus_one;
- if (double_int_cmp (tmax, tem, uns) > 0)
+ if (tmax.cmp (tem, uns) > 0)
covers = true;
/* If the anti-range would cover nothing, drop to varying.
Likewise if the anti-range bounds are outside of the
}
uns = uns0 & uns1;
- mul_double_wide_with_sign (min0.low, min0.high,
- min1.low, min1.high,
- &prod0l.low, &prod0l.high,
- &prod0h.low, &prod0h.high, true);
+ bool overflow;
+ prod0l = min0.wide_mul_with_sign (min1, true, &prod0h, &overflow);
if (!uns0 && min0.is_negative ())
prod0h -= min1;
if (!uns1 && min1.is_negative ())
prod0h -= min0;
- mul_double_wide_with_sign (min0.low, min0.high,
- max1.low, max1.high,
- &prod1l.low, &prod1l.high,
- &prod1h.low, &prod1h.high, true);
+ prod1l = min0.wide_mul_with_sign (max1, true, &prod1h, &overflow);
if (!uns0 && min0.is_negative ())
prod1h -= max1;
if (!uns1 && max1.is_negative ())
prod1h -= min0;
- mul_double_wide_with_sign (max0.low, max0.high,
- min1.low, min1.high,
- &prod2l.low, &prod2l.high,
- &prod2h.low, &prod2h.high, true);
+ prod2l = max0.wide_mul_with_sign (min1, true, &prod2h, &overflow);
if (!uns0 && max0.is_negative ())
prod2h -= min1;
if (!uns1 && min1.is_negative ())
prod2h -= max0;
- mul_double_wide_with_sign (max0.low, max0.high,
- max1.low, max1.high,
- &prod3l.low, &prod3l.high,
- &prod3h.low, &prod3h.high, true);
+ prod3l = max0.wide_mul_with_sign (max1, true, &prod3h, &overflow);
if (!uns0 && max0.is_negative ())
prod3h -= max1;
if (!uns1 && max1.is_negative ())
projects / thirdparty / gcc.git / commitdiff
