15#ifndef LLVM_ADT_APFLOAT_H
16#define LLVM_ADT_APFLOAT_H
26#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \
28 if (usesLayout<IEEEFloat>(getSemantics())) \
29 return U.IEEE.METHOD_CALL; \
30 if (usesLayout<DoubleAPFloat>(getSemantics())) \
31 return U.Double.METHOD_CALL; \
32 llvm_unreachable("Unexpected semantics"); \
43template <
typename T>
class Expected;
44template <
typename T>
class SmallVectorImpl;
301 return semPPCDoubleDoubleLegacy;
309 return semFloat8E4M3B11FNUZ;
318 return semX87DoubleExtended;
506#ifdef HAS_IEE754_FLOAT128
507 LLVM_ABI float128 convertToQuad()
const;
553 bool isZero()
const {
return category == fltCategory::fcZero; }
575 bool isNonZero()
const {
return category != fltCategory::fcZero; }
638 unsigned FormatPrecision = 0,
639 unsigned FormatMaxPadding = 3,
640 bool TruncateZero =
true)
const;
677 LLVM_ABI unsigned int partCount()
const;
690 bool ignoreAddend =
false);
693 void incrementSignificand();
695 void shiftSignificandLeft(
unsigned int);
697 unsigned int significandLSB()
const;
698 unsigned int significandMSB()
const;
699 void zeroSignificand();
700 unsigned int getNumHighBits()
const;
702 bool isSignificandAllOnes()
const;
703 bool isSignificandAllOnesExceptLSB()
const;
705 bool isSignificandAllZeros()
const;
706 bool isSignificandAllZerosExceptMSB()
const;
724 bool convertFromStringSpecials(
StringRef str);
736 char *convertNormalToHexString(
char *,
unsigned int,
bool,
746 template <const fltSemantics &S>
APInt convertIEEEFloatToAPInt()
const;
747 APInt convertHalfAPFloatToAPInt()
const;
748 APInt convertBFloatAPFloatToAPInt()
const;
749 APInt convertFloatAPFloatToAPInt()
const;
750 APInt convertDoubleAPFloatToAPInt()
const;
751 APInt convertQuadrupleAPFloatToAPInt()
const;
752 APInt convertF80LongDoubleAPFloatToAPInt()
const;
753 APInt convertPPCDoubleDoubleLegacyAPFloatToAPInt()
const;
754 APInt convertFloat8E5M2APFloatToAPInt()
const;
755 APInt convertFloat8E5M2FNUZAPFloatToAPInt()
const;
756 APInt convertFloat8E4M3APFloatToAPInt()
const;
757 APInt convertFloat8E4M3FNAPFloatToAPInt()
const;
758 APInt convertFloat8E4M3FNUZAPFloatToAPInt()
const;
759 APInt convertFloat8E4M3B11FNUZAPFloatToAPInt()
const;
760 APInt convertFloat8E3M4APFloatToAPInt()
const;
761 APInt convertFloatTF32APFloatToAPInt()
const;
762 APInt convertFloat8E8M0FNUAPFloatToAPInt()
const;
763 APInt convertFloat6E3M2FNAPFloatToAPInt()
const;
764 APInt convertFloat6E2M3FNAPFloatToAPInt()
const;
765 APInt convertFloat4E2M1FNAPFloatToAPInt()
const;
767 template <const fltSemantics &S>
void initFromIEEEAPInt(
const APInt &api);
768 void initFromHalfAPInt(
const APInt &api);
769 void initFromBFloatAPInt(
const APInt &api);
770 void initFromFloatAPInt(
const APInt &api);
771 void initFromDoubleAPInt(
const APInt &api);
772 void initFromQuadrupleAPInt(
const APInt &api);
773 void initFromF80LongDoubleAPInt(
const APInt &api);
774 void initFromPPCDoubleDoubleLegacyAPInt(
const APInt &api);
775 void initFromFloat8E5M2APInt(
const APInt &api);
776 void initFromFloat8E5M2FNUZAPInt(
const APInt &api);
777 void initFromFloat8E4M3APInt(
const APInt &api);
778 void initFromFloat8E4M3FNAPInt(
const APInt &api);
779 void initFromFloat8E4M3FNUZAPInt(
const APInt &api);
780 void initFromFloat8E4M3B11FNUZAPInt(
const APInt &api);
781 void initFromFloat8E3M4APInt(
const APInt &api);
782 void initFromFloatTF32APInt(
const APInt &api);
783 void initFromFloat8E8M0FNUAPInt(
const APInt &api);
784 void initFromFloat6E3M2FNAPInt(
const APInt &api);
785 void initFromFloat6E2M3FNAPInt(
const APInt &api);
786 void initFromFloat4E2M1FNAPInt(
const APInt &api);
790 void freeSignificand();
811 fltCategory category : 3;
814 unsigned int sign : 1;
839 unsigned int Width,
bool IsSigned,
903 unsigned int Width,
bool IsSigned,
918 unsigned FormatMaxPadding,
919 bool TruncateZero =
true)
const;
944 static_assert(std::is_standard_layout<IEEEFloat>::value);
949 DoubleAPFloat Double;
953 : Double(std::move(
F)) {
957 template <
typename... ArgTypes>
963 if (usesLayout<DoubleAPFloat>(
Semantics)) {
978 static_assert(std::is_same<T, IEEEFloat>::value ||
979 std::is_same<T, DoubleAPFloat>::value);
980 if (std::is_same<T, DoubleAPFloat>::value) {
986 IEEEFloat &getIEEE() {
987 if (usesLayout<IEEEFloat>(*U.semantics))
989 if (usesLayout<DoubleAPFloat>(*U.semantics))
990 return U.Double.getFirst().U.IEEE;
994 const IEEEFloat &getIEEE()
const {
995 if (usesLayout<IEEEFloat>(*U.semantics))
997 if (usesLayout<DoubleAPFloat>(*U.semantics))
998 return U.Double.getFirst().U.IEEE;
1006 void makeNaN(
bool SNaN,
bool Neg,
const APInt *
fill) {
1010 void makeLargest(
bool Neg) {
1014 void makeSmallest(
bool Neg) {
1018 void makeSmallestNormalized(
bool Neg) {
1024 : U(std::move(
F), S) {}
1028 cmpResult compareAbsoluteValue(
const APFloat &
RHS)
const {
1030 "Should only compare APFloats with the same semantics");
1032 return U.IEEE.compareAbsoluteValue(
RHS.U.IEEE);
1034 return U.Double.compareAbsoluteValue(
RHS.U.Double);
1042 template <
typename T,
1043 typename = std::enable_if_t<std::is_floating_point<T>::value>>
1063 Val.makeZero(Negative);
1071 APFloat Val(Sem, 1U);
1082 Val.makeInf(Negative);
1094 APInt intPayload(64, payload);
1095 return getQNaN(Sem, Negative, &intPayload);
1097 return getQNaN(Sem, Negative,
nullptr);
1103 const APInt *payload =
nullptr) {
1105 Val.makeNaN(
false, Negative, payload);
1111 const APInt *payload =
nullptr) {
1113 Val.makeNaN(
true, Negative, payload);
1122 Val.makeLargest(Negative);
1132 Val.makeSmallest(Negative);
1141 bool Negative =
false) {
1143 Val.makeSmallestNormalized(Negative);
1165 "Should only call on two APFloats with the same semantics");
1167 return U.IEEE.add(
RHS.U.IEEE, RM);
1169 return U.Double.add(
RHS.U.Double, RM);
1174 "Should only call on two APFloats with the same semantics");
1176 return U.IEEE.subtract(
RHS.U.IEEE, RM);
1178 return U.Double.subtract(
RHS.U.Double, RM);
1183 "Should only call on two APFloats with the same semantics");
1185 return U.IEEE.multiply(
RHS.U.IEEE, RM);
1187 return U.Double.multiply(
RHS.U.Double, RM);
1192 "Should only call on two APFloats with the same semantics");
1194 return U.IEEE.divide(
RHS.U.IEEE, RM);
1196 return U.Double.divide(
RHS.U.Double, RM);
1201 "Should only call on two APFloats with the same semantics");
1203 return U.IEEE.remainder(
RHS.U.IEEE);
1205 return U.Double.remainder(
RHS.U.Double);
1210 "Should only call on two APFloats with the same semantics");
1212 return U.IEEE.mod(
RHS.U.IEEE);
1214 return U.Double.mod(
RHS.U.Double);
1220 "Should only call on APFloats with the same semantics");
1222 "Should only call on APFloats with the same semantics");
1224 return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
1226 return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
1242 APFloat Result(*
this);
1243 Result.changeSign();
1250 APFloat Result(*
this);
1258 APFloat Result(*
this);
1266 APFloat Result(*
this);
1274 APFloat Result(*
this);
1292 Value.copySign(Sign);
1299 APFloat Result(*
this);
1300 Result.getIEEE().makeQuiet();
1316 bool *IsExact)
const {
1324 bool *IsExact)
const;
1351#ifdef HAS_IEE754_FLOAT128
1352 LLVM_ABI float128 convertToQuad()
const;
1388 "Should only compare APFloats with the same semantics");
1390 return U.IEEE.compare(
RHS.U.IEEE);
1392 return U.Double.compare(
RHS.U.Double);
1400 return U.IEEE.bitwiseIsEqual(
RHS.U.IEEE);
1402 return U.Double.bitwiseIsEqual(
RHS.U.Double);
1461 unsigned FormatMaxPadding = 3,
bool TruncateZero =
true)
const {
1463 toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero));
1468#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1495 friend DoubleAPFloat;
1499 "Empty base class optimization is not performed.");
1517 if (APFloat::usesLayout<detail::IEEEFloat>(Arg.
getSemantics()))
1518 return ilogb(Arg.U.IEEE);
1519 if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.
getSemantics()))
1520 return ilogb(Arg.U.Double);
1526 if (APFloat::usesLayout<detail::IEEEFloat>(
X.getSemantics()))
1528 if (APFloat::usesLayout<detail::DoubleAPFloat>(
X.getSemantics()))
1538 if (APFloat::usesLayout<detail::IEEEFloat>(
X.getSemantics()))
1540 if (APFloat::usesLayout<detail::DoubleAPFloat>(
X.getSemantics()))
1562 if (
A.isSignaling())
1563 return A.makeQuiet();
1564 if (
B.isSignaling())
1565 return B.makeQuiet();
1570 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1571 return A.isNegative() ?
A :
B;
1572 return B <
A ?
B :
A;
1581 if (
A.isSignaling())
1582 return A.makeQuiet();
1583 if (
B.isSignaling())
1584 return B.makeQuiet();
1589 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1590 return A.isNegative() ?
B :
A;
1591 return A <
B ?
B :
A;
1600 return A.makeQuiet();
1602 return B.makeQuiet();
1603 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1604 return A.isNegative() ?
A :
B;
1605 return B <
A ?
B :
A;
1613 return B.isNaN() ?
B.makeQuiet() :
B;
1616 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1617 return A.isNegative() ?
A :
B;
1618 return B <
A ?
B :
A;
1627 return A.makeQuiet();
1629 return B.makeQuiet();
1630 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1631 return A.isNegative() ?
B :
A;
1632 return A <
B ?
B :
A;
1640 return B.isNaN() ?
B.makeQuiet() :
B;
1643 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1644 return A.isNegative() ?
B :
A;
1645 return A <
B ?
B :
A;
1678#undef APFLOAT_DISPATCH_ON_SEMANTICS
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)
This file implements a class to represent arbitrary precision integral constant values and operations...
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Utilities for dealing with flags related to floating point properties and mode controls.
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames)
Initialize the set of available library functions based on the specified target triple.
static const fltSemantics & IEEEsingle()
static const fltSemantics & Float8E4M3FN()
static LLVM_ABI const llvm::fltSemantics & EnumToSemantics(Semantics S)
static LLVM_ABI bool semanticsHasInf(const fltSemantics &)
static constexpr roundingMode rmNearestTiesToAway
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
static constexpr roundingMode rmTowardNegative
static LLVM_ABI ExponentType semanticsMinExponent(const fltSemantics &)
llvm::RoundingMode roundingMode
IEEE-754R 4.3: Rounding-direction attributes.
static const fltSemantics & BFloat()
static constexpr roundingMode rmNearestTiesToEven
static const fltSemantics & IEEEquad()
static LLVM_ABI unsigned int semanticsSizeInBits(const fltSemantics &)
static const fltSemantics & Float8E8M0FNU()
static LLVM_ABI bool semanticsHasSignedRepr(const fltSemantics &)
static const fltSemantics & IEEEdouble()
static LLVM_ABI unsigned getSizeInBits(const fltSemantics &Sem)
Returns the size of the floating point number (in bits) in the given semantics.
static const fltSemantics & x87DoubleExtended()
static constexpr roundingMode rmTowardZero
uninitializedTag
Convenience enum used to construct an uninitialized APFloat.
static LLVM_ABI bool hasSignBitInMSB(const fltSemantics &)
static LLVM_ABI ExponentType semanticsMaxExponent(const fltSemantics &)
static const fltSemantics & Bogus()
A Pseudo fltsemantic used to construct APFloats that cannot conflict with anything real.
static LLVM_ABI unsigned int semanticsPrecision(const fltSemantics &)
static LLVM_ABI bool semanticsHasNaN(const fltSemantics &)
static LLVM_ABI Semantics SemanticsToEnum(const llvm::fltSemantics &Sem)
static constexpr unsigned integerPartWidth
static const fltSemantics & PPCDoubleDoubleLegacy()
APInt::WordType integerPart
static constexpr roundingMode rmTowardPositive
static LLVM_ABI bool semanticsHasZero(const fltSemantics &)
static LLVM_ABI bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
static const fltSemantics & Float8E5M2FNUZ()
static const fltSemantics & Float8E4M3FNUZ()
static const fltSemantics & IEEEhalf()
static const fltSemantics & Float4E2M1FN()
static const fltSemantics & Float6E2M3FN()
IlogbErrorKinds
Enumeration of ilogb error results.
static const fltSemantics & Float8E4M3()
static const fltSemantics & Float8E4M3B11FNUZ()
static LLVM_ABI bool isRepresentableBy(const fltSemantics &A, const fltSemantics &B)
static const fltSemantics & Float8E3M4()
static LLVM_ABI bool isIEEELikeFP(const fltSemantics &)
static const fltSemantics & Float8E5M2()
fltCategory
Category of internally-represented number.
static const fltSemantics & PPCDoubleDouble()
@ S_PPCDoubleDoubleLegacy
static const fltSemantics & Float6E3M2FN()
opStatus
IEEE-754R 7: Default exception handling.
static const fltSemantics & FloatTF32()
int32_t ExponentType
A signed type to represent a floating point numbers unbiased exponent.
static LLVM_ABI unsigned int semanticsIntSizeInBits(const fltSemantics &, bool)
static APFloat getQNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for QNaN values.
static APFloat getSNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for SNaN values.
opStatus divide(const APFloat &RHS, roundingMode RM)
APFloat & operator=(APFloat &&RHS)=default
bool isFiniteNonZero() const
APFloat(const APFloat &RHS)=default
void copySign(const APFloat &RHS)
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
LLVM_READONLY int getExactLog2Abs() const
opStatus subtract(const APFloat &RHS, roundingMode RM)
bool bitwiseIsEqual(const APFloat &RHS) const
bool getExactInverse(APFloat *Inv) const
If this value is normal and has an exact, normal, multiplicative inverse, store it in inv and return ...
APFloat operator+(const APFloat &RHS) const
Add two APFloats, rounding ties to the nearest even.
LLVM_ABI double convertToDouble() const
Converts this APFloat to host double value.
bool isPosInfinity() const
APFloat(APFloat &&RHS)=default
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
bool isExactlyValue(double V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
opStatus add(const APFloat &RHS, roundingMode RM)
LLVM_READONLY int getExactLog2() const
APFloat & operator=(const APFloat &RHS)=default
static LLVM_ABI APFloat getAllOnesValue(const fltSemantics &Semantics)
Returns a float which is bitcasted from an all one value int.
LLVM_ABI friend hash_code hash_value(const APFloat &Arg)
See friend declarations above.
APFloat(const fltSemantics &Semantics, integerPart I)
bool operator!=(const APFloat &RHS) const
APFloat(const fltSemantics &Semantics, T V)=delete
const fltSemantics & getSemantics() const
APFloat operator-(const APFloat &RHS) const
Subtract two APFloats, rounding ties to the nearest even.
APFloat operator*(const APFloat &RHS) const
Multiply two APFloats, rounding ties to the nearest even.
APFloat(const fltSemantics &Semantics)
bool operator<(const APFloat &RHS) const
APFloat makeQuiet() const
Assuming this is an IEEE-754 NaN value, quiet its signaling bit.
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
static APFloat getOne(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative One.
unsigned int convertToHexString(char *DST, unsigned int HexDigits, bool UpperCase, roundingMode RM) const
opStatus multiply(const APFloat &RHS, roundingMode RM)
LLVM_ABI float convertToFloat() const
Converts this APFloat to host float value.
bool operator>(const APFloat &RHS) const
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, roundingMode RM)
APFloat operator/(const APFloat &RHS) const
Divide the first APFloat by the second, rounding ties to the nearest even.
opStatus remainder(const APFloat &RHS)
APFloat operator-() const
Negate an APFloat.
static APFloat getSmallestNormalized(const fltSemantics &Sem, bool Negative=false)
Returns the smallest (by magnitude) normalized finite number in the given semantics.
APInt bitcastToAPInt() const
friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM)
static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)
Returns the largest finite number in the given semantics.
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
opStatus next(bool nextDown)
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Infinity.
friend APFloat scalbn(APFloat X, int Exp, roundingMode RM)
bool operator>=(const APFloat &RHS) const
bool needsCleanup() const
static APFloat getSmallest(const fltSemantics &Sem, bool Negative=false)
Returns the smallest (by magnitude) finite number in the given semantics.
LLVM_ABI FPClassTest classify() const
Return the FPClassTest which will return true for the value.
bool operator==(const APFloat &RHS) const
opStatus mod(const APFloat &RHS)
friend int ilogb(const APFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
LLVM_ABI Expected< opStatus > convertFromString(StringRef, roundingMode)
fltCategory getCategory() const
APFloat(const fltSemantics &Semantics, uninitializedTag)
bool isNegInfinity() const
LLVM_DUMP_METHOD void dump() const
LLVM_ABI void print(raw_ostream &) const
static APFloat copySign(APFloat Value, const APFloat &Sign)
A static helper to produce a copy of an APFloat value with its sign copied from some other APFloat.
opStatus roundToIntegral(roundingMode RM)
static APFloat getNaN(const fltSemantics &Sem, bool Negative=false, uint64_t payload=0)
Factory for NaN values.
static bool hasSignificand(const fltSemantics &Sem)
Returns true if the given semantics has actual significand.
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
cmpResult compare(const APFloat &RHS) const
bool isSmallestNormalized() const
APFloat(const fltSemantics &Semantics, const APInt &I)
bool operator<=(const APFloat &RHS) const
Class for arbitrary precision integers.
static constexpr unsigned APINT_BITS_PER_WORD
Bits in a word.
An arbitrary precision integer that knows its signedness.
Tagged union holding either a T or a Error.
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringRef - Represent a constant reference to a string, i.e.
LLVM Value Representation.
LLVM_ABI void makeSmallestNormalized(bool Neg)
LLVM_ABI DoubleAPFloat & operator=(const DoubleAPFloat &RHS)
LLVM_ABI void changeSign()
LLVM_ABI bool isLargest() const
LLVM_ABI opStatus remainder(const DoubleAPFloat &RHS)
LLVM_ABI opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM)
LLVM_ABI fltCategory getCategory() const
LLVM_ABI bool bitwiseIsEqual(const DoubleAPFloat &RHS) const
LLVM_ABI LLVM_READONLY int getExactLog2Abs() const
LLVM_ABI opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
LLVM_ABI APInt bitcastToAPInt() const
LLVM_ABI Expected< opStatus > convertFromString(StringRef, roundingMode)
LLVM_ABI bool isSmallest() const
LLVM_ABI opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM)
LLVM_ABI friend hash_code hash_value(const DoubleAPFloat &Arg)
LLVM_ABI cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const
LLVM_ABI bool isDenormal() const
LLVM_ABI opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
LLVM_ABI void makeSmallest(bool Neg)
LLVM_ABI friend int ilogb(const DoubleAPFloat &X)
LLVM_ABI opStatus next(bool nextDown)
LLVM_ABI void makeInf(bool Neg)
LLVM_ABI bool isInteger() const
LLVM_ABI void makeZero(bool Neg)
LLVM_ABI opStatus divide(const DoubleAPFloat &RHS, roundingMode RM)
LLVM_ABI bool isSmallestNormalized() const
LLVM_ABI opStatus mod(const DoubleAPFloat &RHS)
LLVM_ABI DoubleAPFloat(const fltSemantics &S)
LLVM_ABI void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision, unsigned FormatMaxPadding, bool TruncateZero=true) const
LLVM_ABI void makeLargest(bool Neg)
LLVM_ABI cmpResult compare(const DoubleAPFloat &RHS) const
LLVM_ABI friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp, roundingMode)
LLVM_ABI opStatus roundToIntegral(roundingMode RM)
LLVM_ABI opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand, const DoubleAPFloat &Addend, roundingMode RM)
LLVM_ABI unsigned int convertToHexString(char *DST, unsigned int HexDigits, bool UpperCase, roundingMode RM) const
bool needsCleanup() const
LLVM_ABI bool isNegative() const
LLVM_ABI opStatus add(const DoubleAPFloat &RHS, roundingMode RM)
LLVM_ABI friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode)
LLVM_ABI void makeNaN(bool SNaN, bool Neg, const APInt *fill)
LLVM_ABI unsigned int convertToHexString(char *dst, unsigned int hexDigits, bool upperCase, roundingMode) const
Write out a hexadecimal representation of the floating point value to DST, which must be of sufficien...
LLVM_ABI cmpResult compareAbsoluteValue(const IEEEFloat &) const
LLVM_ABI opStatus mod(const IEEEFloat &)
C fmod, or llvm frem.
fltCategory getCategory() const
LLVM_ABI opStatus convertFromAPInt(const APInt &, bool, roundingMode)
bool isFiniteNonZero() const
bool needsCleanup() const
Returns whether this instance allocated memory.
LLVM_ABI void makeLargest(bool Neg=false)
Make this number the largest magnitude normal number in the given semantics.
LLVM_ABI LLVM_READONLY int getExactLog2Abs() const
LLVM_ABI APInt bitcastToAPInt() const
LLVM_ABI friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode)
LLVM_ABI cmpResult compare(const IEEEFloat &) const
IEEE comparison with another floating point number (NaNs compare unordered, 0==-0).
bool isNegative() const
IEEE-754R isSignMinus: Returns true if and only if the current value is negative.
LLVM_ABI opStatus divide(const IEEEFloat &, roundingMode)
LLVM_ABI friend hash_code hash_value(const IEEEFloat &Arg)
Overload to compute a hash code for an APFloat value.
bool isNaN() const
Returns true if and only if the float is a quiet or signaling NaN.
LLVM_ABI opStatus remainder(const IEEEFloat &)
IEEE remainder.
LLVM_ABI double convertToDouble() const
LLVM_ABI float convertToFloat() const
LLVM_ABI opStatus subtract(const IEEEFloat &, roundingMode)
LLVM_ABI void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Converts this value into a decimal string.
LLVM_ABI void makeSmallest(bool Neg=false)
Make this number the smallest magnitude denormal number in the given semantics.
LLVM_ABI void makeInf(bool Neg=false)
bool isNormal() const
IEEE-754R isNormal: Returns true if and only if the current value is normal.
LLVM_ABI bool isSmallestNormalized() const
Returns true if this is the smallest (by magnitude) normalized finite number in the given semantics.
friend class IEEEFloatUnitTestHelper
LLVM_ABI void makeQuiet()
LLVM_ABI bool isLargest() const
Returns true if and only if the number has the largest possible finite magnitude in the current seman...
LLVM_ABI opStatus add(const IEEEFloat &, roundingMode)
bool isFinite() const
Returns true if and only if the current value is zero, subnormal, or normal.
LLVM_ABI Expected< opStatus > convertFromString(StringRef, roundingMode)
LLVM_ABI void makeNaN(bool SNaN=false, bool Neg=false, const APInt *fill=nullptr)
LLVM_ABI opStatus multiply(const IEEEFloat &, roundingMode)
LLVM_ABI opStatus roundToIntegral(roundingMode)
LLVM_ABI IEEEFloat & operator=(const IEEEFloat &)
LLVM_ABI bool bitwiseIsEqual(const IEEEFloat &) const
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
LLVM_ABI void makeSmallestNormalized(bool Negative=false)
Returns the smallest (by magnitude) normalized finite number in the given semantics.
LLVM_ABI bool isInteger() const
Returns true if and only if the number is an exact integer.
LLVM_ABI IEEEFloat(const fltSemantics &)
LLVM_ABI opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode)
LLVM_ABI friend int ilogb(const IEEEFloat &Arg)
LLVM_ABI opStatus next(bool nextDown)
IEEE-754R 5.3.1: nextUp/nextDown.
bool isInfinity() const
IEEE-754R isInfinite(): Returns true if and only if the float is infinity.
const fltSemantics & getSemantics() const
bool isZero() const
Returns true if and only if the float is plus or minus zero.
LLVM_ABI bool isSignaling() const
Returns true if and only if the float is a signaling NaN.
bool operator==(const IEEEFloat &) const =delete
The definition of equality is not straightforward for floating point, so we won't use operator==.
LLVM_ABI void makeZero(bool Neg=false)
LLVM_ABI opStatus convert(const fltSemantics &, roundingMode, bool *)
IEEEFloat::convert - convert a value of one floating point type to another.
LLVM_ABI void changeSign()
LLVM_ABI bool isDenormal() const
IEEE-754R isSubnormal(): Returns true if and only if the float is a denormal.
LLVM_ABI opStatus convertToInteger(MutableArrayRef< integerPart >, unsigned int, bool, roundingMode, bool *) const
LLVM_ABI friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode)
LLVM_ABI bool isSmallest() const
Returns true if and only if the number has the smallest possible non-zero magnitude in the current se...
An opaque object representing a hash code.
This class implements an extremely fast bulk output stream that can only output to a stream.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static constexpr opStatus opInexact
static constexpr fltCategory fcNaN
static constexpr opStatus opDivByZero
static constexpr opStatus opOverflow
static constexpr cmpResult cmpLessThan
static constexpr roundingMode rmTowardPositive
static constexpr uninitializedTag uninitialized
static constexpr fltCategory fcZero
static constexpr opStatus opOK
static constexpr cmpResult cmpGreaterThan
static constexpr unsigned integerPartWidth
LLVM_ABI hash_code hash_value(const IEEEFloat &Arg)
APFloatBase::ExponentType ExponentType
APFloatBase::fltCategory fltCategory
static constexpr fltCategory fcNormal
static constexpr opStatus opInvalidOp
APFloatBase::opStatus opStatus
LLVM_ABI IEEEFloat frexp(const IEEEFloat &Val, int &Exp, roundingMode RM)
APFloatBase::uninitializedTag uninitializedTag
static constexpr cmpResult cmpUnordered
static constexpr roundingMode rmTowardNegative
APFloatBase::roundingMode roundingMode
APFloatBase::cmpResult cmpResult
static constexpr fltCategory fcInfinity
static constexpr roundingMode rmNearestTiesToAway
static constexpr roundingMode rmTowardZero
static constexpr opStatus opUnderflow
static constexpr roundingMode rmNearestTiesToEven
LLVM_ABI int ilogb(const IEEEFloat &Arg)
static constexpr cmpResult cmpEqual
LLVM_ABI IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode)
APFloatBase::integerPart integerPart
This is an optimization pass for GlobalISel generic memory operations.
void fill(R &&Range, T &&Value)
Provide wrappers to std::fill which take ranges instead of having to pass begin/end explicitly.
hash_code hash_value(const FixedPointSemantics &Val)
static constexpr APFloatBase::ExponentType exponentZero(const fltSemantics &semantics)
APFloat abs(APFloat X)
Returns the absolute value of the argument.
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximum semantics.
int ilogb(const APFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)
Equivalent of C standard library function.
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2008 maxNum semantics.
lostFraction
Enum that represents what fraction of the LSB truncated bits of an fp number represent.
LLVM_READONLY APFloat minimumnum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimumNumber semantics.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
Returns: X * 2^Exp for integral exponents.
static constexpr APFloatBase::ExponentType exponentNaN(const fltSemantics &semantics)
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2008 minNum semantics.
RoundingMode
Rounding mode.
@ TowardZero
roundTowardZero.
@ NearestTiesToEven
roundTiesToEven.
@ TowardPositive
roundTowardPositive.
@ NearestTiesToAway
roundTiesToAway.
@ TowardNegative
roundTowardNegative.
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
static constexpr APFloatBase::ExponentType exponentInf(const fltSemantics &semantics)
APFloat neg(APFloat X)
Returns the negated value of the argument.
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimum semantics.
LLVM_READONLY APFloat maximumnum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximumNumber semantics.