/* Operations with long integers.
- Copyright (C) 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
+ Copyright (C) 2006-2021 Free Software Foundation, Inc.
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h" /* For SHIFT_COUNT_TRUNCATED. */
+#include "tm.h" /* For BITS_PER_UNIT and *_BIG_ENDIAN. */
#include "tree.h"
static int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
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 *,
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);
+ mul_double_wide_with_sign (l1, h1, l2, h2, lv, hv, NULL, NULL, false)
static int div_and_round_double (unsigned, int, unsigned HOST_WIDE_INT,
HOST_WIDE_INT, unsigned HOST_WIDE_INT,
number. The value of the word is LOWPART + HIGHPART * BASE. */
#define LOWPART(x) \
- ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
+ ((x) & ((HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
#define HIGHPART(x) \
((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
-#define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
+#define BASE (HOST_WIDE_INT_1U << HOST_BITS_PER_WIDE_INT / 2)
/* Unpack a two-word integer into 4 words.
LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
if (l1 == 0)
{
*lv = 0;
- *hv = - h1;
+ *hv = - (unsigned HOST_WIDE_INT) h1;
return (*hv & h1) < 0;
}
else
}
}
-/* Multiply two doubleword integers with doubleword result.
+/* Multiply two doubleword integers with quadword result.
Return nonzero if the operation overflows according to UNSIGNED_P.
Each argument is given as two `HOST_WIDE_INT' pieces.
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. */
-
-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,
- bool unsigned_p)
-{
- unsigned HOST_WIDE_INT toplow;
- HOST_WIDE_INT tophigh;
-
- return mul_double_wide_with_sign (l1, h1, l2, h2,
- lv, hv, &toplow, &tophigh,
- unsigned_p);
-}
+ The value is stored as four `HOST_WIDE_INT' pieces in *LV and *HV,
+ *LW and *HW.
+ If lw is NULL then only the low part and no overflow is computed. */
static int
mul_double_wide_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
}
decode (prod, lv, hv);
+
+ /* We are not interested in the wide part nor in overflow. */
+ if (lw == NULL)
+ return 0;
+
decode (prod + 4, lw, hw);
/* Unsigned overflow is immediate. */
? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
: 0);
- if (SHIFT_COUNT_TRUNCATED)
- count %= prec;
-
if (count >= HOST_BITS_PER_DOUBLE_INT)
{
/* Shifting by the host word size is undefined according to the
;
else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
{
- *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
+ *hv &= ~(HOST_WIDE_INT_M1U << (prec - count - HOST_BITS_PER_WIDE_INT));
*hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
}
else
{
*hv = signmask;
- *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
+ *lv &= ~(HOST_WIDE_INT_M1U << (prec - count));
*lv |= signmask << (prec - count);
}
}
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)
+ unsigned HOST_WIDE_INT count, unsigned int prec,
+ unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
{
unsigned HOST_WIDE_INT signmask;
- if (count < 0)
- {
- rshift_double (l1, h1, absu_hwi (count), prec, lv, hv, arith);
- return;
- }
-
- if (SHIFT_COUNT_TRUNCATED)
- count %= prec;
-
if (count >= HOST_BITS_PER_DOUBLE_INT)
{
/* Shifting by the host word size is undefined according to the
;
else if (prec >= HOST_BITS_PER_WIDE_INT)
{
- *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
+ *hv &= ~(HOST_WIDE_INT_M1U << (prec - HOST_BITS_PER_WIDE_INT));
*hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
}
else
{
*hv = signmask;
- *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
+ *lv &= ~(HOST_WIDE_INT_M1U << prec);
*lv |= signmask << prec;
}
}
if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
{
/* quo = quo - 1; */
- add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
+ add_double (*lquo, *hquo, HOST_WIDE_INT_M1, HOST_WIDE_INT_M1,
lquo, hquo);
}
else
case CEIL_MOD_EXPR: /* round toward positive infinity */
if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
{
- add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
+ add_double (*lquo, *hquo, HOST_WIDE_INT_1, HOST_WIDE_INT_0,
lquo, hquo);
}
else
{
unsigned HOST_WIDE_INT labs_rem = *lrem;
HOST_WIDE_INT habs_rem = *hrem;
- unsigned HOST_WIDE_INT labs_den = lden, ltwice;
- HOST_WIDE_INT habs_den = hden, htwice;
+ unsigned HOST_WIDE_INT labs_den = lden, lnegabs_rem, ldiff;
+ HOST_WIDE_INT habs_den = hden, hnegabs_rem, hdiff;
/* Get absolute values. */
- if (*hrem < 0)
+ if (!uns && *hrem < 0)
neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
- if (hden < 0)
+ if (!uns && hden < 0)
neg_double (lden, hden, &labs_den, &habs_den);
- /* If (2 * abs (lrem) >= abs (lden)), adjust the quotient. */
- mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
- labs_rem, habs_rem, <wice, &htwice);
+ /* If abs(rem) >= abs(den) - abs(rem), adjust the quotient. */
+ neg_double (labs_rem, habs_rem, &lnegabs_rem, &hnegabs_rem);
+ add_double (labs_den, habs_den, lnegabs_rem, hnegabs_rem,
+ &ldiff, &hdiff);
- if (((unsigned HOST_WIDE_INT) habs_den
- < (unsigned HOST_WIDE_INT) htwice)
- || (((unsigned HOST_WIDE_INT) habs_den
- == (unsigned HOST_WIDE_INT) htwice)
- && (labs_den <= ltwice)))
+ if (((unsigned HOST_WIDE_INT) habs_rem
+ > (unsigned HOST_WIDE_INT) hdiff)
+ || (habs_rem == hdiff && labs_rem >= ldiff))
{
- if (*hquo < 0)
+ if (quo_neg)
/* quo = quo - 1; */
add_double (*lquo, *hquo,
- (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
+ HOST_WIDE_INT_M1, HOST_WIDE_INT_M1, lquo, hquo);
else
/* quo = quo + 1; */
- add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
+ add_double (*lquo, *hquo, HOST_WIDE_INT_1, HOST_WIDE_INT_0,
lquo, hquo);
}
else
return overflow;
}
+
+/* Construct from a buffer of length LEN. BUFFER will be read according
+ to byte endianness and word endianness. Only the lower LEN bytes
+ of the result are set; the remaining high bytes are cleared. */
+
+double_int
+double_int::from_buffer (const unsigned char *buffer, int len)
+{
+ double_int result = double_int_zero;
+ int words = len / UNITS_PER_WORD;
+
+ gcc_assert (len * BITS_PER_UNIT <= HOST_BITS_PER_DOUBLE_INT);
+
+ for (int byte = 0; byte < len; byte++)
+ {
+ int offset;
+ int bitpos = byte * BITS_PER_UNIT;
+ unsigned HOST_WIDE_INT value;
+
+ if (len > UNITS_PER_WORD)
+ {
+ int word = byte / UNITS_PER_WORD;
+
+ if (WORDS_BIG_ENDIAN)
+ word = (words - 1) - word;
+
+ offset = word * UNITS_PER_WORD;
+
+ if (BYTES_BIG_ENDIAN)
+ offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
+ else
+ offset += byte % UNITS_PER_WORD;
+ }
+ else
+ offset = BYTES_BIG_ENDIAN ? (len - 1) - byte : byte;
+
+ value = (unsigned HOST_WIDE_INT) buffer[offset];
+
+ if (bitpos < HOST_BITS_PER_WIDE_INT)
+ result.low |= value << bitpos;
+ else
+ result.high |= value << (bitpos - HOST_BITS_PER_WIDE_INT);
+ }
+
+ return result;
+}
+
+
/* Returns mask for PREC bits. */
double_int
return ret;
}
+/* Multiplies *this with B and returns a reference to *this. */
+
+double_int &
+double_int::operator *= (double_int b)
+{
+ mul_double (low, high, b.low, b.high, &low, &high);
+ return *this;
+}
+
/* Returns A * B. If the operation overflows according to UNSIGNED_P,
*OVERFLOW is set to nonzero. */
double_int::mul_with_sign (double_int b, bool unsigned_p, bool *overflow) const
{
const double_int &a = *this;
- double_int ret;
- *overflow = mul_double_with_sign (a.low, a.high, b.low, b.high,
- &ret.low, &ret.high, unsigned_p);
+ double_int ret, tem;
+ *overflow = mul_double_wide_with_sign (a.low, a.high, b.low, b.high,
+ &ret.low, &ret.high,
+ &tem.low, &tem.high, unsigned_p);
return ret;
}
return ret;
}
+/* Adds B to *this and returns a reference to *this. */
+
+double_int &
+double_int::operator += (double_int b)
+{
+ add_double (low, high, b.low, b.high, &low, &high);
+ return *this;
+}
+
+
/* Returns A + B. If the operation overflows according to UNSIGNED_P,
*OVERFLOW is set to nonzero. */
return ret;
}
+/* Subtracts B from *this and returns a reference to *this. */
+
+double_int &
+double_int::operator -= (double_int b)
+{
+ neg_double (b.low, b.high, &b.low, &b.high);
+ add_double (low, high, b.low, b.high, &low, &high);
+ return *this;
+}
+
+
/* Returns A - B. If the operation overflows via inconsistent sign bits,
*OVERFLOW is set to nonzero. */
{
double_int a = *this;
if (bitpos < HOST_BITS_PER_WIDE_INT)
- a.low |= (unsigned HOST_WIDE_INT) 1 << bitpos;
+ a.low |= HOST_WIDE_INT_1U << bitpos;
else
- a.high |= (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
+ a.high |= HOST_WIDE_INT_1 << (bitpos - HOST_BITS_PER_WIDE_INT);
return a;
}
return bits;
}
+/* Shift A left by COUNT places. */
+
+double_int
+double_int::lshift (HOST_WIDE_INT count) const
+{
+ double_int ret;
+
+ gcc_checking_assert (count >= 0);
+
+ if (count >= HOST_BITS_PER_DOUBLE_INT)
+ {
+ /* Shifting by the host word size is undefined according to the
+ ANSI standard, so we must handle this as a special case. */
+ ret.high = 0;
+ ret.low = 0;
+ }
+ else if (count >= HOST_BITS_PER_WIDE_INT)
+ {
+ ret.high = low << (count - HOST_BITS_PER_WIDE_INT);
+ ret.low = 0;
+ }
+ else
+ {
+ ret.high = (((unsigned HOST_WIDE_INT) high << count)
+ | (low >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
+ ret.low = low << count;
+ }
+
+ return ret;
+}
+
+/* Shift A right by COUNT places. */
+
+double_int
+double_int::rshift (HOST_WIDE_INT count) const
+{
+ double_int ret;
+
+ gcc_checking_assert (count >= 0);
+
+ if (count >= HOST_BITS_PER_DOUBLE_INT)
+ {
+ /* Shifting by the host word size is undefined according to the
+ ANSI standard, so we must handle this as a special case. */
+ ret.high = 0;
+ ret.low = 0;
+ }
+ else if (count >= HOST_BITS_PER_WIDE_INT)
+ {
+ ret.high = 0;
+ ret.low
+ = (unsigned HOST_WIDE_INT) (high >> (count - HOST_BITS_PER_WIDE_INT));
+ }
+ else
+ {
+ ret.high = high >> count;
+ ret.low = ((low >> count)
+ | ((unsigned HOST_WIDE_INT) high
+ << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
+ }
+
+ return ret;
+}
+
/* Shift A left by COUNT places keeping only PREC bits of result. Shift
right if COUNT is negative. ARITH true specifies arithmetic shifting;
otherwise use logical shift. */
double_int
double_int::lshift (HOST_WIDE_INT count, unsigned int prec, bool arith) const
{
- const double_int &a = *this;
double_int ret;
- lshift_double (a.low, a.high, count, prec, &ret.low, &ret.high, arith);
+ if (count > 0)
+ lshift_double (low, high, count, prec, &ret.low, &ret.high);
+ else
+ rshift_double (low, high, absu_hwi (count), prec, &ret.low, &ret.high, arith);
return ret;
}
double_int
double_int::rshift (HOST_WIDE_INT count, unsigned int prec, bool arith) const
{
- const double_int &a = *this;
double_int ret;
- lshift_double (a.low, a.high, -count, prec, &ret.low, &ret.high, arith);
+ if (count > 0)
+ rshift_double (low, high, count, prec, &ret.low, &ret.high, arith);
+ else
+ lshift_double (low, high, absu_hwi (count), prec, &ret.low, &ret.high);
return ret;
}
double_int::alshift (HOST_WIDE_INT count, unsigned int prec) const
{
double_int r;
- lshift_double (low, high, count, prec, &r.low, &r.high, true);
+ if (count > 0)
+ lshift_double (low, high, count, prec, &r.low, &r.high);
+ else
+ rshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high, true);
return r;
}
double_int::arshift (HOST_WIDE_INT count, unsigned int prec) const
{
double_int r;
- lshift_double (low, high, -count, prec, &r.low, &r.high, true);
+ if (count > 0)
+ rshift_double (low, high, count, prec, &r.low, &r.high, true);
+ else
+ lshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high);
return r;
}
double_int::llshift (HOST_WIDE_INT count, unsigned int prec) const
{
double_int r;
- lshift_double (low, high, count, prec, &r.low, &r.high, false);
+ if (count > 0)
+ lshift_double (low, high, count, prec, &r.low, &r.high);
+ else
+ rshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high, false);
return r;
}
double_int::lrshift (HOST_WIDE_INT count, unsigned int prec) const
{
double_int r;
- lshift_double (low, high, -count, prec, &r.low, &r.high, false);
+ if (count > 0)
+ rshift_double (low, high, count, prec, &r.low, &r.high, false);
+ else
+ lshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high);
return r;
}
if (count < 0)
count += prec;
- t1 = this->lshift (count, prec, false);
- t2 = this->rshift (prec - count, prec, false);
+ t1 = this->llshift (count, prec);
+ t2 = this->lrshift (prec - count, prec);
return t1 | t2;
}
if (count < 0)
count += prec;
- t1 = this->rshift (count, prec, false);
- t2 = this->lshift (prec - count, prec, false);
+ t1 = this->lrshift (count, prec);
+ t2 = this->llshift (prec - count, prec);
return t1 | t2;
}
for representing the value. The code to calculate count is
extracted from the GMP manual, section "Integer Import and Export":
http://gmplib.org/manual/Integer-Import-and-Export.html */
- numb = 8*sizeof(HOST_WIDE_INT);
+ numb = 8 * sizeof (HOST_WIDE_INT);
count = (mpz_sizeinbase (val, 2) + numb-1) / numb;
if (count < 2)
count = 2;
- vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof(HOST_WIDE_INT));
+ vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof (HOST_WIDE_INT));
vp[0] = 0;
vp[1] = 0;
projects / thirdparty / gcc.git / blobdiff