Lines Matching full:apint
346 lsb = APInt::tcLSB(parts, partCount);
354 APInt::tcExtractBit(parts, bits - 1))
368 APInt::tcShiftRight(dst, parts, bits);
484 APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
494 APInt::tcFullMultiply(p2, p1, pow5, result, pc);
508 APInt::tcAssign(dst, p1, result);
610 APInt::tcAssign(significandParts(), rhs.significandParts(),
617 void APFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill)
627 APInt::tcSet(significand, 0, numParts);
629 APInt::tcAssign(significand, fill->getRawData(),
645 APInt::tcClearBit(significand, QNaNBit);
650 if (APInt::tcIsZero(significand, numParts))
651 APInt::tcSetBit(significand, QNaNBit - 1);
654 APInt::tcSetBit(significand, QNaNBit);
661 APInt::tcSetBit(significand, QNaNBit + 1);
665 const APInt *fill) {
702 (APInt::tcExtractBit(significandParts(),
866 APInt::tcSet(significandParts(), 0, partCount());
875 carry = APInt::tcIncrement(significandParts(), partCount());
893 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
908 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
942 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
946 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
975 APInt::tcShiftLeft(fullSignificand, newPartsCount,
1010 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1036 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
1079 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
1082 APInt::tcShiftLeft(divisor, partsCount, bit);
1086 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
1089 APInt::tcShiftLeft(dividend, partsCount, bit);
1095 if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
1097 APInt::tcShiftLeft(dividend, partsCount, 1);
1098 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1103 if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
1104 APInt::tcSubtract(dividend, divisor, 0, partsCount);
1105 APInt::tcSetBit(lhsSignificand, bit - 1);
1108 APInt::tcShiftLeft(dividend, partsCount, 1);
1112 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1118 else if (APInt::tcIsZero(dividend, partsCount))
1132 return APInt::tcMSB(significandParts(), partCount());
1138 return APInt::tcLSB(significandParts(), partCount());
1162 APInt::tcShiftLeft(significandParts(), partsCount, bits);
1165 assert(!APInt::tcIsZero(significandParts(), partsCount));
1183 compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
1211 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1243 return APInt::tcExtractBit(significandParts(), bit);
1861 APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
2019 APInt::tcSet(newParts, 0, newPartCount);
2021 APInt::tcAssign(newParts, significandParts(), oldPartCount);
2039 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
2050 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2094 APInt::tcSet(parts, 0, dstPartsCount);
2106 APInt::tcSet(parts, 0, dstPartsCount);
2122 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
2125 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
2126 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
2138 if (APInt::tcIncrement(parts, dstPartsCount))
2146 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
2157 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
2165 APInt::tcNegate (parts, dstPartsCount);
2209 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
2211 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
2230 result = APInt(bitWidth, parts);
2247 omsb = APInt::tcMSB(src, srcCount) + 1;
2258 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2262 APInt::tcExtract(dst, dstCount, src, omsb, 0);
2269 APFloat::convertFromAPInt(const APInt &Val,
2274 APInt api = Val;
2297 APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
2303 APInt::tcAssign(copy, src, srcCount);
2304 APInt::tcNegate(copy, srcCount);
2315 /* FIXME: should this just take a const APInt reference? */
2322 APInt api = APInt(width, makeArrayRef(parts, partCount));
2325 if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
2472 assert(APInt::tcExtractBit
2482 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2597 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2869 APInt
2898 return APInt(80, words);
2901 APInt
2949 return APInt(128, words);
2952 APInt
2985 return APInt(128, words);
2988 APInt
3013 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
3018 APInt
3043 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
3047 APInt
3072 return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
3076 // This function creates an APInt that is just a bit map of the floating
3080 APInt
3108 APInt api = bitcastToAPInt();
3117 APInt api = bitcastToAPInt();
3129 APFloat::initFromF80LongDoubleAPInt(const APInt &api)
3163 APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
3172 initFromDoubleAPInt(APInt(64, i1));
3179 APFloat v(IEEEdouble, APInt(64, i2));
3189 APFloat::initFromQuadrupleAPInt(const APInt &api)
3229 APFloat::initFromDoubleAPInt(const APInt &api)
3262 APFloat::initFromFloatAPInt(const APInt & api)
3295 APFloat::initFromHalfAPInt(const APInt & api)
3328 /// we infer the floating point type from the size of the APInt. The
3332 APFloat::initFromAPInt(const fltSemantics* Sem, const APInt& api)
3355 return APFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
3357 return APFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
3359 return APFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
3361 return APFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
3364 return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
3365 return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
3406 APInt::tcSet(significandParts(), 1, partCount());
3448 APFloat::APFloat(const fltSemantics &Sem, const APInt &API) {
3453 initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
3457 initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
3467 void AdjustToPrecision(APInt &significand,
3481 APInt divisor(significand.getBitWidth(), 1);
3482 APInt powten(significand.getBitWidth(), 10);
3573 // Decompose the number into an APInt and an exponent.
3575 APInt significand(semantics->precision,
3622 APInt five_to_the_i(precision, 5);
3638 APInt ten(precision, 10);
3639 APInt digit(precision, 0);
3645 APInt::udivrem(significand, ten, significand, digit);
3782 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
3823 APInt::tcSet(significandParts(), 0, partCount());
3831 APInt::tcSet(significandParts(), 0, partCount());
3863 APInt::tcDecrement(Parts, partCount());
3869 APInt::tcSetBit(Parts, semantics->precision - 1);
3885 APInt::tcSet(Parts, 0, partCount());
3886 APInt::tcSetBit(Parts, semantics->precision - 1);
3910 APInt::tcSet(significandParts(), 0, partCount());
3918 APInt::tcSet(significandParts(), 0, partCount());
