xemu-project/xemu
1
0
Fork 0
mirror of https://github.com/xemu-project/xemu.git synced 2024-11-23 03:29:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

libdecnumber: Introduce decNumberIntegralToInt128

Browse Source 
This will be used to implement PowerPC's dctfixqq.

Signed-off-by: Luis Pires <luis.pires@eldorado.org.br>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20211029192417.400707-7-luis.pires@eldorado.org.br>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
This commit is contained in:
Luis Pires 2021-10-29 16:24:08 -03:00 committed by David Gibson
parent e06049f380
commit 21d7826fdb
4 changed files with 102 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/libdecnumber/decNumber.h
View File

@ -124,6 +124,8 @@
uint32_t decNumberToUInt32(const decNumber *, decContext *);
int32_t decNumberToInt32(const decNumber *, decContext *);
int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set);
void decNumberIntegralToInt128(const decNumber *dn, decContext *set,
uint64_t *plow, uint64_t *phigh);
uint8_t * decNumberGetBCD(const decNumber *, uint8_t *);
decNumber * decNumberSetBCD(decNumber *, const uint8_t *, uint32_t);

2
include/libdecnumber/decNumberLocal.h
View File

@ -98,7 +98,7 @@
/* Shared lookup tables */
extern const uByte DECSTICKYTAB[10]; /* re-round digits if sticky */
extern const uLong DECPOWERS[19]; /* powers of ten table */
extern const uLong DECPOWERS[20]; /* powers of ten table */
/* The following are included from decDPD.h */
extern const uShort DPD2BIN[1024]; /* DPD -> 0-999 */
extern const uShort BIN2DPD[1000]; /* 0-999 -> DPD */

7
libdecnumber/decContext.c
View File

@ -53,12 +53,13 @@ static const Flag *mfctop=(Flag *)&mfcone; /* -> top byte */
const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
/* ------------------------------------------------------------------ */
/* Powers of ten (powers[n]==10**n, 0<=n<=9) */
/* Powers of ten (powers[n]==10**n, 0<=n<=19) */
/* ------------------------------------------------------------------ */
const uLong DECPOWERS[19] = {1, 10, 100, 1000, 10000, 100000, 1000000,
const uLong DECPOWERS[20] = {1, 10, 100, 1000, 10000, 100000, 1000000,
10000000, 100000000, 1000000000, 10000000000ULL, 100000000000ULL,
1000000000000ULL, 10000000000000ULL, 100000000000000ULL, 1000000000000000ULL,
10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL, };
10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL,
10000000000000000000ULL,};
/* ------------------------------------------------------------------ */
/* decContextClearStatus -- clear bits in current status */

95
libdecnumber/decNumber.c
View File

@ -264,6 +264,7 @@ static decNumber * decTrim(decNumber *, decContext *, Flag, Int *);
static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
Unit *, Int);
static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
static bool mulUInt128ByPowOf10(uLong *, uLong *, uInt);
#if !DECSUBSET
/* decFinish == decFinalize when no subset arithmetic needed */
@ -542,6 +543,68 @@ Invalid:
return 0;
} /* decNumberIntegralToInt64 */
/* ------------------------------------------------------------------ */
/* decNumberIntegralToInt128 -- conversion to int128 */
/* */
/* dn is the decNumber to convert. dn is assumed to have been */
/* rounded to a floating point integer value. */
/* set is the context for reporting errors */
/* returns the converted decNumber via plow and phigh */
/* */
/* Invalid is set if the decNumber is a NaN, Infinite or is out of */
/* range for a signed 128 bit integer. */
/* ------------------------------------------------------------------ */
void decNumberIntegralToInt128(const decNumber *dn, decContext *set,
uint64_t *plow, uint64_t *phigh)
{
int d; /* work */
const Unit *up; /* .. */
uint64_t lo = 0, hi = 0;
if (decNumberIsSpecial(dn) || (dn->exponent < 0) ||
(dn->digits + dn->exponent > 39)) {
goto Invalid;
}
up = dn->lsu; /* -> lsu */
for (d = (dn->digits - 1) / DECDPUN; d >= 0; d--) {
if (mulu128(&lo, &hi, DECDPUNMAX + 1)) {
/* overflow */
goto Invalid;
}
if (uadd64_overflow(lo, up[d], &lo)) {
if (uadd64_overflow(hi, 1, &hi)) {
/* overflow */
goto Invalid;
}
}
}
if (mulUInt128ByPowOf10(&lo, &hi, dn->exponent)) {
/* overflow */
goto Invalid;
}
if (decNumberIsNegative(dn)) {
if (lo == 0) {
*phigh = -hi;
*plow = 0;
} else {
*phigh = ~hi;
*plow = -lo;
}
} else {
*plow = lo;
*phigh = hi;
}
return;
Invalid:
decContextSetStatus(set, DEC_Invalid_operation);
} /* decNumberIntegralToInt128 */
/* ------------------------------------------------------------------ */
/* to-scientific-string -- conversion to numeric string */
@ -7885,6 +7948,38 @@ static Int decGetDigits(Unit *uar, Int len) {
return digits;
} /* decGetDigits */
/* ------------------------------------------------------------------ */
/* mulUInt128ByPowOf10 -- multiply a 128-bit unsigned integer by a */
/* power of 10. */
/* */
/* The 128-bit factor composed of plow and phigh is multiplied */
/* by 10^exp. */
/* */
/* plow pointer to the low 64 bits of the first factor */
/* phigh pointer to the high 64 bits of the first factor */
/* exp the exponent of the power of 10 of the second factor */
/* */
/* If the result fits in 128 bits, returns false and the */
/* multiplication result through plow and phigh. */
/* Otherwise, returns true. */
/* ------------------------------------------------------------------ */
static bool mulUInt128ByPowOf10(uLong *plow, uLong *phigh, uInt pow10)
{
while (pow10 >= ARRAY_SIZE(powers)) {
if (mulu128(plow, phigh, powers[ARRAY_SIZE(powers) - 1])) {
/* Overflow */
return true;
}
pow10 -= ARRAY_SIZE(powers) - 1;
}
if (pow10 > 0) {
return mulu128(plow, phigh, powers[pow10]);
} else {
return false;
}
}
#if DECTRACE | DECCHECK
/* ------------------------------------------------------------------ */
/* decNumberShow -- display a number [debug aid] */