Lines Matching refs:APInt
359 lsb = APInt::tcLSB(parts, partCount);
367 APInt::tcExtractBit(parts, bits - 1))
381 APInt::tcShiftRight(dst, parts, bits);
497 APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
507 APInt::tcFullMultiply(p2, p1, pow5, result, pc);
521 APInt::tcAssign(dst, p1, result);
625 APInt::tcAssign(significandParts(), rhs.significandParts(),
632 void APFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill)
642 APInt::tcSet(significand, 0, numParts);
644 APInt::tcAssign(significand, fill->getRawData(),
660 APInt::tcClearBit(significand, QNaNBit);
665 if (APInt::tcIsZero(significand, numParts))
666 APInt::tcSetBit(significand, QNaNBit - 1);
669 APInt::tcSetBit(significand, QNaNBit);
676 APInt::tcSetBit(significand, QNaNBit + 1);
680 const APInt *fill) {
823 APInt::tcSet(significandParts(), 0, partCount());
832 carry = APInt::tcIncrement(significandParts(), partCount());
850 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
865 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
896 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
900 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
913 APInt::tcShiftLeft(fullSignificand, newPartsCount,
940 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
956 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
999 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
1002 APInt::tcShiftLeft(divisor, partsCount, bit);
1006 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
1009 APInt::tcShiftLeft(dividend, partsCount, bit);
1015 if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
1017 APInt::tcShiftLeft(dividend, partsCount, 1);
1018 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1023 if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
1024 APInt::tcSubtract(dividend, divisor, 0, partsCount);
1025 APInt::tcSetBit(lhsSignificand, bit - 1);
1028 APInt::tcShiftLeft(dividend, partsCount, 1);
1032 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1038 else if (APInt::tcIsZero(dividend, partsCount))
1052 return APInt::tcMSB(significandParts(), partCount());
1058 return APInt::tcLSB(significandParts(), partCount());
1082 APInt::tcShiftLeft(significandParts(), partsCount, bits);
1085 assert(!APInt::tcIsZero(significandParts(), partsCount));
1103 compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
1131 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1163 return APInt::tcExtractBit(significandParts(), bit);
1885 APInt::tcSet(newParts, 0, newPartCount);
1887 APInt::tcAssign(newParts, significandParts(), oldPartCount);
1905 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
1956 APInt::tcSet(parts, 0, dstPartsCount);
1968 APInt::tcSet(parts, 0, dstPartsCount);
1984 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
1987 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
1988 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
2000 if (APInt::tcIncrement(parts, dstPartsCount))
2008 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
2019 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
2027 APInt::tcNegate (parts, dstPartsCount);
2071 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
2073 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
2092 result = APInt(bitWidth, parts);
2110 omsb = APInt::tcMSB(src, srcCount) + 1;
2121 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2125 APInt::tcExtract(dst, dstCount, src, omsb, 0);
2132 APFloat::convertFromAPInt(const APInt &Val,
2137 APInt api = Val;
2161 APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
2167 APInt::tcAssign(copy, src, srcCount);
2168 APInt::tcNegate(copy, srcCount);
2179 /* FIXME: should this just take a const APInt reference? */
2186 APInt api = APInt(width, makeArrayRef(parts, partCount));
2189 if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
2346 assert(APInt::tcExtractBit
2356 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2463 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2709 APInt
2738 return APInt(80, words);
2741 APInt
2783 return APInt(128, words);
2786 APInt
2819 return APInt(128, words);
2822 APInt
2847 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
2852 APInt
2877 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
2881 APInt
2906 return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
2910 // This function creates an APInt that is just a bit map of the floating
2914 APInt
2942 APInt api = bitcastToAPInt();
2951 APInt api = bitcastToAPInt();
2963 APFloat::initFromF80LongDoubleAPInt(const APInt &api)
2997 APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
3047 APFloat::initFromQuadrupleAPInt(const APInt &api)
3087 APFloat::initFromDoubleAPInt(const APInt &api)
3120 APFloat::initFromFloatAPInt(const APInt & api)
3153 APFloat::initFromHalfAPInt(const APInt & api)
3186 /// we infer the floating point type from the size of the APInt. The
3190 APFloat::initFromAPInt(const APInt& api, bool isIEEE)
3210 return APFloat(APInt::getAllOnesValue(BitWidth), isIEEE);
3268 APFloat::APFloat(const APInt& api, bool isIEEE) : exponent2(0), sign2(0) {
3273 initFromAPInt(APInt::floatToBits(f));
3277 initFromAPInt(APInt::doubleToBits(d));
3295 void AdjustToPrecision(APInt &significand,
3309 APInt divisor(significand.getBitWidth(), 1);
3310 APInt powten(significand.getBitWidth(), 10);
3403 // Decompose the number into an APInt and an exponent.
3405 APInt significand(semantics->precision,
3449 APInt five_to_the_i(precision, 5);
3465 APInt ten(precision, 10);
3466 APInt digit(precision, 0);
3472 APInt::udivrem(significand, ten, significand, digit);
