Lines Matching defs:semantics
37 llvm_unreachable("Unexpected semantics"); \
102 /* Represents floating point arithmetic semantics. */
116 /* Number of bits actually used in the semantics. */
123 /* Whether this semantics has an encoding for Zero */
126 /* Whether this semantics can represent signed values */
206 llvm_unreachable("Unrecognised floating semantics");
252 llvm_unreachable("Unknown floating semantics");
315 unsigned int APFloatBase::semanticsPrecision(const fltSemantics &semantics) {
316 return semantics.precision;
319 APFloatBase::semanticsMaxExponent(const fltSemantics &semantics) {
320 return semantics.maxExponent;
323 APFloatBase::semanticsMinExponent(const fltSemantics &semantics) {
324 return semantics.minExponent;
326 unsigned int APFloatBase::semanticsSizeInBits(const fltSemantics &semantics) {
327 return semantics.sizeInBits;
329 unsigned int APFloatBase::semanticsIntSizeInBits(const fltSemantics &semantics,
333 unsigned int MinBitWidth = semanticsMaxExponent(semantics) + 1;
340 bool APFloatBase::semanticsHasZero(const fltSemantics &semantics) {
341 return semantics.hasZero;
344 bool APFloatBase::semanticsHasSignedRepr(const fltSemantics &semantics) {
345 return semantics.hasSignedRepr;
348 bool APFloatBase::semanticsHasInf(const fltSemantics &semantics) {
349 return semantics.nonFiniteBehavior == fltNonfiniteBehavior::IEEE754;
352 bool APFloatBase::semanticsHasNaN(const fltSemantics &semantics) {
353 return semantics.nonFiniteBehavior != fltNonfiniteBehavior::FiniteOnly;
375 exponentZero(const fltSemantics &semantics) {
376 return semantics.minExponent - 1;
380 exponentInf(const fltSemantics &semantics) {
381 return semantics.maxExponent + 1;
385 exponentNaN(const fltSemantics &semantics) {
386 if (semantics.nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
387 if (semantics.nanEncoding == fltNanEncoding::NegativeZero)
388 return exponentZero(semantics);
389 if (semantics.hasSignedRepr)
390 return semantics.maxExponent;
392 return semantics.maxExponent + 1;
889 semantics = ourSemantics;
901 assert(semantics == rhs.semantics);
922 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::FiniteOnly)
925 if (Negative && !semantics->hasSignedRepr)
937 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
941 if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
943 fill_storage = APInt::getZero(semantics->precision - 1);
945 fill_storage = APInt::getAllOnes(semantics->precision - 1);
958 unsigned bitsToPreserve = semantics->precision - 1;
967 (semantics->precision >= 2) ? (semantics->precision - 2) : 0;
978 } else if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
989 if (semantics == &semX87DoubleExtended)
995 if (semantics != rhs.semantics) {
997 initialize(rhs.semantics);
1008 semantics = rhs.semantics;
1014 rhs.semantics = &semBogus;
1019 return isFiniteNonZero() && (exponent == semantics->minExponent) &&
1021 semantics->precision - 1) == 0);
1028 return isFiniteNonZero() && exponent == semantics->minExponent &&
1033 return getCategory() == fcNormal && exponent == semantics->minExponent &&
1038 const unsigned int PartCount = partCountForBits(semantics->precision);
1044 const unsigned int NumHighBits = (semantics->precision > 1)
1045 ? (Bits - semantics->precision + 1)
1046 : (Bits - semantics->precision);
1054 const unsigned PartCount = partCountForBits(semantics->precision);
1065 if ((semantics->precision <= 1) || (~(Parts[PartCount - 1] | HighBitFill)))
1079 const unsigned PartCount = partCountForBits(semantics->precision);
1101 const unsigned PartCount = partCountForBits(semantics->precision);
1113 if ((semantics->precision > 1) && (Parts[PartCount - 1] & HighBitMask))
1121 const unsigned PartCount = partCountForBits(semantics->precision);
1131 return ((semantics->precision <= 1) || (Parts[PartCount - 1] == MSBMask));
1135 bool IsMaxExp = isFiniteNonZero() && exponent == semantics->maxExponent;
1136 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1137 semantics->nanEncoding == fltNanEncoding::AllOnes) {
1141 return (IsMaxExp && APFloat::hasSignificand(*semantics))
1162 if (semantics != rhs.semantics ||
1203 initialize(rhs.semantics);
1207 IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&semBogus) {
1214 return partCountForBits(semantics->precision + 1);
1249 assert(semantics == rhs.semantics);
1263 assert(semantics == rhs.semantics);
1284 assert(semantics == rhs.semantics);
1286 precision = semantics->precision;
1324 const fltSemantics *savedSemantics = semantics;
1338 /* Create new semantics. */
1339 extendedSemantics = *semantics;
1346 semantics = &extendedSemantics;
1348 // Make a copy so we can convert it to the extended semantics.
1370 semantics = savedSemantics;
1408 // When the given semantics has zero, the addend here is a zero.
1410 // But when the semantics does not support zero, we need to
1413 return multiplySignificand(rhs, IEEEFloat(*semantics), !semantics->hasZero);
1424 assert(semantics == rhs.semantics);
1446 unsigned int precision = semantics->precision;
1519 assert(bits < semantics->precision ||
1520 (semantics->precision == 1 && bits <= 1));
1535 assert(semantics == rhs.semantics);
1575 if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::FiniteOnly) {
1581 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
1591 exponent = semantics->maxExponent;
1593 semantics->precision);
1594 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1595 semantics->nanEncoding == fltNanEncoding::AllOnes)
1659 exponentChange = omsb - semantics->precision;
1663 if (exponent + exponentChange > semantics->maxExponent)
1668 if (exponent + exponentChange < semantics->minExponent)
1669 exponentChange = semantics->minExponent - exponent;
1698 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1699 semantics->nanEncoding == fltNanEncoding::AllOnes &&
1700 exponent == semantics->maxExponent && isSignificandAllOnes())
1712 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
1714 if (!semantics->hasZero)
1724 exponent = semantics->minExponent;
1730 if (omsb == (unsigned) semantics->precision + 1) {
1734 if (exponent == semantics->maxExponent)
1748 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
1749 semantics->nanEncoding == fltNanEncoding::AllOnes &&
1750 exponent == semantics->maxExponent && isSignificandAllOnes())
1756 if (omsb == semantics->precision)
1760 assert(omsb < semantics->precision);
1765 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
1767 // This condition handles the case where the semantics
1770 if (!semantics->hasZero)
1850 if ((bits < 0) && !semantics->hasSignedRepr)
1984 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
2080 if (semantics->nanEncoding == fltNanEncoding::NegativeZero &&
2113 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2140 if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
2160 if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
2187 // using the same semantics).
2232 // Extend the semantics to prevent an overflow/underflow or inexact result.
2234 fltSemantics extendedSemantics = *semantics;
2255 // Make VEx = this.add(this), but because we have different semantics, we do
2272 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2300 // When the semantics supports zero, this loop's
2302 // category check above. However, when the semantics
2307 if (!semantics->hasZero && this->isSmallest())
2314 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2346 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
2418 if (exponent + 1 >= (int)APFloat::semanticsPrecision(*semantics))
2427 APInt IntegerConstant(NextPowerOf2(APFloat::semanticsPrecision(*semantics)),
2429 IntegerConstant <<= APFloat::semanticsPrecision(*semantics) - 1;
2430 IEEEFloat MagicConstant(*semantics);
2457 assert(semantics == rhs.semantics);
2538 const fltSemantics &fromSemantics = *semantics;
2556 // If this is a truncation of a denormal number, and the target semantics
2557 // has larger exponent range than the source semantics (this can happen
2582 (category == fcNaN && semantics->nonFiniteBehavior !=
2605 // Now that we have the right storage, switch the semantics.
2606 semantics = &toSemantics;
2617 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
2627 semantics->nanEncoding != fltNanEncoding::NegativeZero)
2634 if (!X86SpecialNan && semantics == &semX87DoubleExtended)
2635 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2647 semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
2652 semantics->nanEncoding == fltNanEncoding::NegativeZero) {
2664 if (category == fcZero && !semantics->hasZero)
2711 truncatedBits = semantics->precision -1U - exponent;
2721 if (bits < semantics->precision) {
2722 /* We truncate (semantics->precision - bits) bits. */
2723 truncatedBits = semantics->precision - bits;
2727 APInt::tcExtract(parts.data(), dstPartsCount, src, semantics->precision,
2730 bits - semantics->precision);
2835 precision = semantics->precision;
2993 expAdjustment += semantics->precision;
3018 parts = partCountForBits(semantics->precision + 11);
3028 excessPrecision = calcSemantics.precision - semantics->precision;
3053 if (decSig.exponent < semantics->minExponent) {
3054 excessPrecision += (semantics->minExponent - decSig.exponent);
3081 exponent = (decSig.exponent + semantics->precision
3128 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
3130 if (!semantics->hasZero)
3144 8651 * (semantics->minExponent - (int) semantics->precision)) {
3152 >= 12655 * semantics->maxExponent) {
3299 if (sign && !semantics->hasSignedRepr)
3411 valueBits = semantics->precision + 3;
3498 Arg.semantics->precision);
3502 Arg.semantics->precision, Arg.exponent,
3518 assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended);
3548 assert(semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy);
3561 fltSemantics extendedSemantics = *semantics;
3598 assert(semantics == &S);
3600 (semantics == &semFloat8E8M0FNU) ? -S.minExponent : -(S.minExponent - 1);
3625 llvm_unreachable("semantics does not support zero!");
3631 llvm_unreachable("semantics don't support inf!");
3637 llvm_unreachable("semantics don't support NaN!");
3753 if (semantics == (const llvm::fltSemantics*)&semIEEEhalf)
3756 if (semantics == (const llvm::fltSemantics *)&semBFloat)
3759 if (semantics == (const llvm::fltSemantics*)&semIEEEsingle)
3762 if (semantics == (const llvm::fltSemantics*)&semIEEEdouble)
3765 if (semantics == (const llvm::fltSemantics*)&semIEEEquad)
3768 if (semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy)
3771 if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2)
3774 if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2FNUZ)
3777 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3)
3780 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FN)
3783 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FNUZ)
3786 if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3B11FNUZ)
3789 if (semantics == (const llvm::fltSemantics *)&semFloat8E3M4)
3792 if (semantics == (const llvm::fltSemantics *)&semFloatTF32)
3795 if (semantics == (const llvm::fltSemantics *)&semFloat8E8M0FNU)
3798 if (semantics == (const llvm::fltSemantics *)&semFloat6E3M2FN)
3801 if (semantics == (const llvm::fltSemantics *)&semFloat6E2M3FN)
3804 if (semantics == (const llvm::fltSemantics *)&semFloat4E2M1FN)
3807 assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended &&
3813 assert(semantics == (const llvm::fltSemantics*)&semIEEEsingle &&
3814 "Float semantics are not IEEEsingle");
3820 assert(semantics == (const llvm::fltSemantics*)&semIEEEdouble &&
3821 "Float semantics are not IEEEdouble");
3828 assert(semantics == (const llvm::fltSemantics *)&semIEEEquad &&
3829 "Float semantics are not IEEEquads");
4118 llvm_unreachable("unsupported semantics");
4122 /// semantics.
4124 if (Negative && !semantics->hasSignedRepr)
4133 exponent = semantics->maxExponent;
4143 PartCount*integerPartWidth - semantics->precision;
4147 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
4148 semantics->nanEncoding == fltNanEncoding::AllOnes &&
4149 (semantics->precision > 1))
4154 /// semantics.
4156 if (Negative && !semantics->hasSignedRepr)
4165 exponent = semantics->minExponent;
4170 if (Negative && !semantics->hasSignedRepr)
4181 exponent = semantics->minExponent;
4182 APInt::tcSetBit(significandParts(), semantics->precision - 1);
4323 // <= semantics->precision + e * 137 / 59
4507 int exp = exponent - ((int) semantics->precision - 1);
4509 semantics->precision,
4510 ArrayRef(significandParts(), partCountForBits(semantics->precision)));
4524 if (significandLSB() != semantics->precision - 1)
4528 IEEEFloat reciprocal(*semantics, 1ULL);
4538 reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
4541 *inv = APFloat(reciprocal, *semantics);
4551 const int PartCount = partCountForBits(semantics->precision);
4560 if (exponent != semantics->minExponent)
4567 return exponent - semantics->precision + CountrParts +
4578 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly ||
4579 semantics->nonFiniteBehavior == fltNonfiniteBehavior::FiniteOnly)
4584 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
4628 if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
4630 if (!semantics->hasZero)
4636 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
4640 } else if (semantics->nonFiniteBehavior ==
4648 exponent = semantics->maxExponent + 1;
4659 // 1. exponent != semantics->minExponent. This implies we are not in the
4663 exponent != semantics->minExponent && isSignificandAllZeros();
4685 APInt::tcSetBit(Parts, semantics->precision - 1);
4699 bool WillCrossBinadeBoundary = !APFloat::hasSignificand(*semantics) ||
4705 APInt::tcSetBit(Parts, semantics->precision - 1);
4706 assert(exponent != semantics->maxExponent &&
4708 " by the given floating point semantics.");
4725 return ::exponentNaN(*semantics);
4729 return ::exponentInf(*semantics);
4733 return ::exponentZero(*semantics);
4737 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::FiniteOnly)
4740 if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
4752 if (!semantics->hasZero)
4757 if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
4767 if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::NanOnly)
4768 APInt::tcSetBit(significandParts(), semantics->precision - 2);
5427 llvm_unreachable("Unexpected semantics");
5440 llvm_unreachable("Unexpected semantics");
5485 llvm_unreachable("Unexpected semantics");
5529 "Float semantics is not representable by IEEEdouble");
5543 "Float semantics is not representable by IEEEquad");
5557 "Float semantics is not representable by IEEEsingle");