Lines Matching defs:semantics
37 llvm_unreachable("Unexpected semantics"); \
102 /* Represents floating point arithmetic semantics. */
116 /* Number of bits actually used in the semantics. */
122 // Returns true if any number described by this semantics can be precisely
123 // represented by the specified semantics. Does not take into account
156 /* The IBM double-double semantics. Such a number consists of a pair of IEEE
167 /* These are legacy semantics for the fallback, inaccrurate implementation of
179 Currently, these semantics are used in the following way:
190 semantics. */
231 llvm_unreachable("Unrecognised floating semantics");
271 llvm_unreachable("Unknown floating semantics");
323 unsigned int APFloatBase::semanticsPrecision(const fltSemantics &semantics) {
324 return semantics.precision;
327 APFloatBase::semanticsMaxExponent(const fltSemantics &semantics) {
328 return semantics.maxExponent;
331 APFloatBase::semanticsMinExponent(const fltSemantics &semantics) {
332 return semantics.minExponent;
334 unsigned int APFloatBase::semanticsSizeInBits(const fltSemantics &semantics) {
335 return semantics.sizeInBits;
337 unsigned int APFloatBase::semanticsIntSizeInBits(const fltSemantics &semantics,
341 unsigned int MinBitWidth = semanticsMaxExponent(semantics) + 1;
367 exponentZero(const fltSemantics &semantics) {
368 return semantics.minExponent - 1;
372 exponentInf(const fltSemantics &semantics) {
373 return semantics.maxExponent + 1;
377 exponentNaN(const fltSemantics &semantics) {
378 if (semantics.nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
379 if (semantics.nanEncoding == fltNanEncoding::NegativeZero)
380 return exponentZero(semantics);
381 return semantics.maxExponent;
383 return semantics.maxExponent + 1;
879 semantics = ourSemantics;
891 assert(semantics == rhs.semantics);
912 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::FiniteOnly)
923 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
927 if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
929 fill_storage = APInt::getZero(semantics->precision - 1);
931 fill_storage = APInt::getAllOnes(semantics->precision - 1);
944 unsigned bitsToPreserve = semantics->precision - 1;
952 unsigned QNaNBit = semantics->precision - 2;
963 } else if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
974 if (semantics == &semX87DoubleExtended)
980 if (semantics != rhs.semantics) {
982 initialize(rhs.semantics);
993 semantics = rhs.semantics;
999 rhs.semantics = &semBogus;
1004 return isFiniteNonZero() && (exponent == semantics->minExponent) &&
1006 semantics->precision - 1) == 0);
1013 return isFiniteNonZero() && exponent == semantics->minExponent &&
1018 return getCategory() == fcNormal && exponent == semantics->minExponent &&
1026 const unsigned PartCount = partCountForBits(semantics->precision);
1033 PartCount*integerPartWidth - semantics->precision + 1;
1052 const unsigned PartCount = partCountForBits(semantics->precision);
1060 PartCount * integerPartWidth - semantics->precision + 1;
1075 const unsigned PartCount = partCountForBits(semantics->precision);
1083 PartCount*integerPartWidth - semantics->precision + 1;
1096 const unsigned PartCount = partCountForBits(semantics->precision);
1104 PartCount * integerPartWidth - semantics->precision + 1;
1110 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1111 semantics->nanEncoding == fltNanEncoding::AllOnes) {
1115 return isFiniteNonZero() && exponent == semantics->maxExponent &&
1120 return isFiniteNonZero() && exponent == semantics->maxExponent &&
1136 if (semantics != rhs.semantics ||
1171 initialize(rhs.semantics);
1175 IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&semBogus) {
1182 return partCountForBits(semantics->precision + 1);
1217 assert(semantics == rhs.semantics);
1231 assert(semantics == rhs.semantics);
1251 assert(semantics == rhs.semantics);
1253 precision = semantics->precision;
1291 const fltSemantics *savedSemantics = semantics;
1305 /* Create new semantics. */
1306 extendedSemantics = *semantics;
1313 semantics = &extendedSemantics;
1315 // Make a copy so we can convert it to the extended semantics.
1336 semantics = savedSemantics;
1374 return multiplySignificand(rhs, IEEEFloat(*semantics));
1385 assert(semantics == rhs.semantics);
1407 unsigned int precision = semantics->precision;
1480 assert(bits < semantics->precision);
1496 assert(semantics == rhs.semantics);
1536 if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::FiniteOnly) {
1542 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
1552 exponent = semantics->maxExponent;
1554 semantics->precision);
1555 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1556 semantics->nanEncoding == fltNanEncoding::AllOnes)
1620 exponentChange = omsb - semantics->precision;
1624 if (exponent + exponentChange > semantics->maxExponent)
1629 if (exponent + exponentChange < semantics->minExponent)
1630 exponentChange = semantics->minExponent - exponent;
1659 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1660 semantics->nanEncoding == fltNanEncoding::AllOnes &&
1661 exponent == semantics->maxExponent && isSignificandAllOnes())
1673 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
1683 exponent = semantics->minExponent;
1689 if (omsb == (unsigned) semantics->precision + 1) {
1693 if (exponent == semantics->maxExponent)
1707 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1708 semantics->nanEncoding == fltNanEncoding::AllOnes &&
1709 exponent == semantics->maxExponent && isSignificandAllOnes())
1715 if (omsb == semantics->precision)
1719 assert(omsb < semantics->precision);
1724 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
1934 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
2030 if (semantics->nanEncoding == fltNanEncoding::NegativeZero &&
2063 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2090 if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
2110 if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
2137 // using the same semantics).
2182 // Extend the semantics to prevent an overflow/underflow or inexact result.
2184 fltSemantics extendedSemantics = *semantics;
2205 // Make VEx = this.add(this), but because we have different semantics, we do
2222 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2253 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2285 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2357 if (exponent+1 >= (int)semanticsPrecision(*semantics))
2366 APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
2367 IntegerConstant <<= semanticsPrecision(*semantics)-1;
2368 IEEEFloat MagicConstant(*semantics);
2396 assert(semantics == rhs.semantics);
2477 const fltSemantics &fromSemantics = *semantics;
2495 // If this is a truncation of a denormal number, and the target semantics
2496 // has larger exponent range than the source semantics (this can happen
2521 (category == fcNaN && semantics->nonFiniteBehavior !=
2544 // Now that we have the right storage, switch the semantics.
2545 semantics = &toSemantics;
2556 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
2566 semantics->nanEncoding != fltNanEncoding::NegativeZero)
2573 if (!X86SpecialNan && semantics == &semX87DoubleExtended)
2574 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2586 semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
2591 semantics->nanEncoding == fltNanEncoding::NegativeZero) {
2648 truncatedBits = semantics->precision -1U - exponent;
2658 if (bits < semantics->precision) {
2659 /* We truncate (semantics->precision - bits) bits. */
2660 truncatedBits = semantics->precision - bits;
2664 APInt::tcExtract(parts.data(), dstPartsCount, src, semantics->precision,
2667 bits - semantics->precision);
2772 precision = semantics->precision;
2930 expAdjustment += semantics->precision;
2955 parts = partCountForBits(semantics->precision + 11);
2965 excessPrecision = calcSemantics.precision - semantics->precision;
2990 if (decSig.exponent < semantics->minExponent) {
2991 excessPrecision += (semantics->minExponent - decSig.exponent);
3018 exponent = (decSig.exponent + semantics->precision
3065 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
3079 8651 * (semantics->minExponent - (int) semantics->precision)) {
3087 >= 12655 * semantics->maxExponent) {
3342 valueBits = semantics->precision + 3;
3429 Arg.semantics->precision);
3433 Arg.semantics->precision, Arg.exponent,
3449 assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended);
3479 assert(semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy);
3492 fltSemantics extendedSemantics = *semantics;
3529 assert(semantics == &S);
3559 llvm_unreachable("semantics don't support inf!");
3565 llvm_unreachable("semantics don't support NaN!");
3671 if (semantics == (const llvm::fltSemantics*)&semIEEEhalf)
3674 if (semantics == (const llvm::fltSemantics *)&semBFloat)
3677 if (semantics == (const llvm::fltSemantics*)&semIEEEsingle)
3680 if (semantics == (const llvm::fltSemantics*)&semIEEEdouble)
3683 if (semantics == (const llvm::fltSemantics*)&semIEEEquad)
3686 if (semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy)
3689 if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2)
3692 if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2FNUZ)
3695 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3)
3698 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FN)
3701 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FNUZ)
3704 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3B11FNUZ)
3707 if (semantics == (const llvm::fltSemantics *)&semFloatTF32)
3710 if (semantics == (const llvm::fltSemantics *)&semFloat6E3M2FN)
3713 if (semantics == (const llvm::fltSemantics *)&semFloat6E2M3FN)
3716 if (semantics == (const llvm::fltSemantics *)&semFloat4E2M1FN)
3719 assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended &&
3725 assert(semantics == (const llvm::fltSemantics*)&semIEEEsingle &&
3726 "Float semantics are not IEEEsingle");
3732 assert(semantics == (const llvm::fltSemantics*)&semIEEEdouble &&
3733 "Float semantics are not IEEEdouble");
3740 assert(semantics == (const llvm::fltSemantics *)&semIEEEquad &&
3741 "Float semantics are not IEEEquads");
3993 /// semantics.
4001 exponent = semantics->maxExponent;
4011 PartCount*integerPartWidth - semantics->precision;
4016 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
4017 semantics->nanEncoding == fltNanEncoding::AllOnes)
4022 /// semantics.
4030 exponent = semantics->minExponent;
4043 exponent = semantics->minExponent;
4044 APInt::tcSetBit(significandParts(), semantics->precision - 1);
4185 // <= semantics->precision + e * 137 / 59
4369 int exp = exponent - ((int) semantics->precision - 1);
4371 semantics->precision,
4372 ArrayRef(significandParts(), partCountForBits(semantics->precision)));
4386 if (significandLSB() != semantics->precision - 1)
4390 IEEEFloat reciprocal(*semantics, 1ULL);
4400 reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
4403 *inv = APFloat(reciprocal, *semantics);
4413 const int PartCount = partCountForBits(semantics->precision);
4422 if (exponent != semantics->minExponent)
4429 return exponent - semantics->precision + CountrParts +
4440 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
4441 semantics->nonFiniteBehavior == fltNonfiniteBehavior::FiniteOnly)
4446 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
4490 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
4496 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
4500 } else if (semantics->nonFiniteBehavior ==
4508 exponent = semantics->maxExponent + 1;
4519 // 1. exponent != semantics->minExponent. This implies we are not in the
4523 exponent != semantics->minExponent && isSignificandAllZeros();
4545 APInt::tcSetBit(Parts, semantics->precision - 1);
4562 APInt::tcSetBit(Parts, semantics->precision - 1);
4563 assert(exponent != semantics->maxExponent &&
4565 " by the given floating point semantics.");
4582 return ::exponentNaN(*semantics);
4586 return ::exponentInf(*semantics);
4590 return ::exponentZero(*semantics);
4594 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::FiniteOnly)
4597 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
4611 if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
4621 if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::NanOnly)
4622 APInt::tcSetBit(significandParts(), semantics->precision - 2);
5281 llvm_unreachable("Unexpected semantics");
5294 llvm_unreachable("Unexpected semantics");
5339 llvm_unreachable("Unexpected semantics");
5380 "Float semantics is not representable by IEEEdouble");
5394 "Float semantics is not representable by IEEEquad");
5408 "Float semantics is not representable by IEEEsingle");