Lines Matching refs:APInt
347 lsb = APInt::tcLSB(parts, partCount);
355 APInt::tcExtractBit(parts, bits - 1))
369 APInt::tcShiftRight(dst, parts, bits);
485 APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
495 APInt::tcFullMultiply(p2, p1, pow5, result, pc);
509 APInt::tcAssign(dst, p1, result);
611 APInt::tcAssign(significandParts(), rhs.significandParts(),
618 void APFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill)
628 APInt::tcSet(significand, 0, numParts);
630 APInt::tcAssign(significand, fill->getRawData(),
646 APInt::tcClearBit(significand, QNaNBit);
651 if (APInt::tcIsZero(significand, numParts))
652 APInt::tcSetBit(significand, QNaNBit - 1);
655 APInt::tcSetBit(significand, QNaNBit);
662 APInt::tcSetBit(significand, QNaNBit + 1);
666 const APInt *fill) {
703 (APInt::tcExtractBit(significandParts(),
867 APInt::tcSet(significandParts(), 0, partCount());
876 carry = APInt::tcIncrement(significandParts(), partCount());
894 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
909 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
940 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
944 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
972 APInt::tcShiftLeft(fullSignificand, newPartsCount,
999 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1025 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
1068 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
1071 APInt::tcShiftLeft(divisor, partsCount, bit);
1075 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
1078 APInt::tcShiftLeft(dividend, partsCount, bit);
1084 if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
1086 APInt::tcShiftLeft(dividend, partsCount, 1);
1087 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1092 if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
1093 APInt::tcSubtract(dividend, divisor, 0, partsCount);
1094 APInt::tcSetBit(lhsSignificand, bit - 1);
1097 APInt::tcShiftLeft(dividend, partsCount, 1);
1101 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1107 else if (APInt::tcIsZero(dividend, partsCount))
1121 return APInt::tcMSB(significandParts(), partCount());
1127 return APInt::tcLSB(significandParts(), partCount());
1151 APInt::tcShiftLeft(significandParts(), partsCount, bits);
1154 assert(!APInt::tcIsZero(significandParts(), partsCount));
1172 compare = APInt
1200 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1232 return APInt::tcExtractBit(significandParts(), bit);
1850 APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
2008 APInt::tcSet(newParts, 0, newPartCount);
2010 APInt::tcAssign(newParts, significandParts(), oldPartCount);
2028 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
2039 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2083 APInt::tcSet(parts, 0, dstPartsCount);
2095 APInt::tcSet(parts, 0, dstPartsCount);
2111 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
2114 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
2115 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
2127 if (APInt::tcIncrement(parts, dstPartsCount))
2135 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
2146 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
2154 APInt::tcNegate (parts, dstPartsCount);
2198 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
2200 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
2219 result = APInt(bitWidth, parts);
2236 omsb = APInt::tcMSB(src, srcCount) + 1;
2247 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2251 APInt::tcExtract(dst, dstCount, src, omsb, 0);
2258 APFloat::convertFromAPInt(const APInt &Val,
2263 APInt api = Val;
2286 APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
2292 APInt::tcAssign(copy, src, srcCount);
2293 APInt::tcNegate(copy, srcCount);
2304 /* FIXME: should this just take a const APInt reference? */
2311 APInt api = APInt(width, makeArrayRef(parts, partCount));
2314 if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
2461 assert(APInt::tcExtractBit
2471 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2586 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2858 APInt
2887 return APInt(80, words);
2890 APInt
2938 return APInt(128, words);
2941 APInt
2974 return APInt(128, words);
2977 APInt
3002 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
3007 APInt
3032 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
3036 APInt
3061 return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
3065 // This function creates an APInt that is just a bit map of the floating
3069 APInt
3097 APInt api = bitcastToAPInt();
3106 APInt api = bitcastToAPInt();
3118 APFloat::initFromF80LongDoubleAPInt(const APInt &api)
3152 APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
3161 initFromDoubleAPInt(APInt(64, i1));
3168 APFloat v(IEEEdouble, APInt(64, i2));
3178 APFloat::initFromQuadrupleAPInt(const APInt &api)
3218 APFloat::initFromDoubleAPInt(const APInt &api)
3251 APFloat::initFromFloatAPInt(const APInt & api)
3284 APFloat::initFromHalfAPInt(const APInt & api)
3317 /// we infer the floating point type from the size of the APInt. The
3321 APFloat::initFromAPInt(const fltSemantics* Sem, const APInt& api)
3344 return APFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
3346 return APFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
3348 return APFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
3350 return APFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
3353 return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
3354 return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
3393 APInt::tcSet(significandParts(), 1, partCount());
3435 APFloat::APFloat(const fltSemantics &Sem, const APInt &API) {
3440 initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
3444 initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
3454 void AdjustToPrecision(APInt &significand,
3468 APInt divisor(significand.getBitWidth(), 1);
3469 APInt powten(significand.getBitWidth(), 10);
3560 // Decompose the number into an APInt and an exponent.
3562 APInt significand(semantics->precision,
3609 APInt five_to_the_i(precision, 5);
3625 APInt ten(precision, 10);
3626 APInt digit(precision, 0);
3632 APInt::udivrem(significand, ten, significand, digit);
3769 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
3810 APInt::tcSet(significandParts(), 0, partCount());
3818 APInt::tcSet(significandParts(), 0, partCount());
3850 APInt::tcDecrement(Parts, partCount());
3856 APInt::tcSetBit(Parts, semantics->precision - 1);
3872 APInt::tcSet(Parts, 0, partCount());
3873 APInt::tcSetBit(Parts, semantics->precision - 1);
3897 APInt::tcSet(significandParts(), 0, partCount());
3905 APInt::tcSet(significandParts(), 0, partCount());
