Lines Matching full: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. */
194 const llvm::fltSemantics &APFloatBase::EnumToSemantics(Semantics S) {
231 llvm_unreachable("Unrecognised floating semantics");
234 APFloatBase::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);
4684 : Semantics(&S),
4686 assert(Semantics == &semPPCDoubleDouble);
4690 : Semantics(&S),
4693 assert(Semantics == &semPPCDoubleDouble);
4697 : Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
4699 assert(Semantics == &semPPCDoubleDouble);
4703 : Semantics(&S),
4707 assert(Semantics == &semPPCDoubleDouble);
4712 : Semantics(&S),
4714 assert(Semantics == &semPPCDoubleDouble);
4720 : Semantics(RHS.Semantics),
4724 assert(Semantics == &semPPCDoubleDouble);
4728 : Semantics(RHS.Semantics), Floats(std::move(RHS.Floats)) {
4729 RHS.Semantics = &semBogus;
4730 assert(Semantics == &semPPCDoubleDouble);
4734 if (Semantics == RHS.Semantics && RHS.Floats) {
4973 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4982 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4991 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5002 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5012 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5062 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5070 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5076 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5104 return hash_combine(Arg.Semantics);
5108 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5118 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5126 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5137 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5145 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5156 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5167 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5178 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5216 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5224 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5230 assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5252 assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5259 assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
5269 APFloat::Storage::Storage(IEEEFloat F, const fltSemantics &Semantics) {
5270 if (usesLayout<IEEEFloat>(Semantics)) {
5274 if (usesLayout<DoubleAPFloat>(Semantics)) {
5277 DoubleAPFloat(Semantics, APFloat(std::move(F), S),
5281 llvm_unreachable("Unexpected semantics");
5294 llvm_unreachable("Unexpected semantics");
5297 APFloat::APFloat(const fltSemantics &Semantics, StringRef S)
5298 : APFloat(Semantics) {
5339 llvm_unreachable("Unexpected semantics");
5342 APFloat APFloat::getAllOnesValue(const fltSemantics &Semantics) {
5343 return APFloat(Semantics, APInt::getAllOnes(Semantics.sizeInBits));
5380 "Float semantics is not representable by IEEEdouble");
5394 "Float semantics is not representable by IEEEquad");
5408 "Float semantics is not representable by IEEEsingle");