15#ifndef LLVM_ADT_APFLOAT_H
16#define LLVM_ADT_APFLOAT_H
24#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \
26 if (usesLayout<IEEEFloat>(getSemantics())) \
27 return U.IEEE.METHOD_CALL; \
28 if (usesLayout<DoubleAPFloat>(getSemantics())) \
29 return U.Double.METHOD_CALL; \
30 llvm_unreachable("Unexpected semantics"); \
41template <
typename T>
class Expected;
42template <
typename T>
class SmallVectorImpl;
486 unsigned FormatMaxPadding = 3,
bool TruncateZero =
true)
const;
525 void makeNaN(
bool SNaN =
false,
bool Neg =
false,
526 const APInt *fill =
nullptr);
527 void makeInf(
bool Neg =
false);
547 unsigned int partCount()
const;
560 void incrementSignificand();
562 void shiftSignificandLeft(
unsigned int);
564 unsigned int significandLSB()
const;
565 unsigned int significandMSB()
const;
566 void zeroSignificand();
568 bool isSignificandAllOnes()
const;
569 bool isSignificandAllOnesExceptLSB()
const;
571 bool isSignificandAllZeros()
const;
572 bool isSignificandAllZerosExceptMSB()
const;
590 bool convertFromStringSpecials(
StringRef str);
602 char *convertNormalToHexString(
char *,
unsigned int,
bool,
612 template <const fltSemantics &S>
APInt convertIEEEFloatToAPInt()
const;
613 APInt convertHalfAPFloatToAPInt()
const;
614 APInt convertBFloatAPFloatToAPInt()
const;
615 APInt convertFloatAPFloatToAPInt()
const;
616 APInt convertDoubleAPFloatToAPInt()
const;
617 APInt convertQuadrupleAPFloatToAPInt()
const;
618 APInt convertF80LongDoubleAPFloatToAPInt()
const;
619 APInt convertPPCDoubleDoubleAPFloatToAPInt()
const;
620 APInt convertFloat8E5M2APFloatToAPInt()
const;
621 APInt convertFloat8E5M2FNUZAPFloatToAPInt()
const;
622 APInt convertFloat8E4M3FNAPFloatToAPInt()
const;
623 APInt convertFloat8E4M3FNUZAPFloatToAPInt()
const;
624 APInt convertFloat8E4M3B11FNUZAPFloatToAPInt()
const;
625 APInt convertFloatTF32APFloatToAPInt()
const;
627 template <const fltSemantics &S>
void initFromIEEEAPInt(
const APInt &api);
628 void initFromHalfAPInt(
const APInt &api);
629 void initFromBFloatAPInt(
const APInt &api);
630 void initFromFloatAPInt(
const APInt &api);
631 void initFromDoubleAPInt(
const APInt &api);
632 void initFromQuadrupleAPInt(
const APInt &api);
633 void initFromF80LongDoubleAPInt(
const APInt &api);
634 void initFromPPCDoubleDoubleAPInt(
const APInt &api);
635 void initFromFloat8E5M2APInt(
const APInt &api);
636 void initFromFloat8E5M2FNUZAPInt(
const APInt &api);
637 void initFromFloat8E4M3FNAPInt(
const APInt &api);
638 void initFromFloat8E4M3FNUZAPInt(
const APInt &api);
639 void initFromFloat8E4M3B11FNUZAPInt(
const APInt &api);
640 void initFromFloatTF32APInt(
const APInt &api);
644 void freeSignificand();
668 unsigned int sign : 1;
672int ilogb(
const IEEEFloat &Arg);
683 std::unique_ptr<APFloat[]> Floats;
740 bool *IsExact)
const;
743 unsigned int InputSize,
bool IsSigned,
746 unsigned int InputSize,
bool IsSigned,
758 unsigned FormatMaxPadding,
bool TruncateZero =
true)
const;
782 static_assert(std::is_standard_layout<IEEEFloat>::value);
791 : Double(std::move(
F)) {
795 template <
typename... ArgTypes>
801 if (usesLayout<DoubleAPFloat>(
Semantics)) {
809 if (usesLayout<IEEEFloat>(*semantics)) {
813 if (usesLayout<DoubleAPFloat>(*semantics)) {
814 Double.~DoubleAPFloat();
820 Storage(
const Storage &
RHS) {
821 if (usesLayout<IEEEFloat>(*
RHS.semantics)) {
825 if (usesLayout<DoubleAPFloat>(*
RHS.semantics)) {
832 Storage(Storage &&
RHS) {
833 if (usesLayout<IEEEFloat>(*
RHS.semantics)) {
837 if (usesLayout<DoubleAPFloat>(*
RHS.semantics)) {
844 Storage &operator=(
const Storage &
RHS) {
845 if (usesLayout<IEEEFloat>(*semantics) &&
846 usesLayout<IEEEFloat>(*
RHS.semantics)) {
848 }
else if (usesLayout<DoubleAPFloat>(*semantics) &&
849 usesLayout<DoubleAPFloat>(*
RHS.semantics)) {
851 }
else if (
this != &
RHS) {
853 new (
this) Storage(
RHS);
858 Storage &operator=(Storage &&
RHS) {
859 if (usesLayout<IEEEFloat>(*semantics) &&
860 usesLayout<IEEEFloat>(*
RHS.semantics)) {
862 }
else if (usesLayout<DoubleAPFloat>(*semantics) &&
863 usesLayout<DoubleAPFloat>(*
RHS.semantics)) {
864 Double = std::move(
RHS.Double);
865 }
else if (
this != &
RHS) {
867 new (
this) Storage(std::move(
RHS));
874 static_assert(std::is_same<T, IEEEFloat>::value ||
875 std::is_same<T, DoubleAPFloat>::value);
876 if (std::is_same<T, DoubleAPFloat>::value) {
883 if (usesLayout<IEEEFloat>(*U.semantics))
885 if (usesLayout<DoubleAPFloat>(*U.semantics))
886 return U.Double.getFirst().U.IEEE;
891 if (usesLayout<IEEEFloat>(*U.semantics))
893 if (usesLayout<DoubleAPFloat>(*U.semantics))
894 return U.Double.getFirst().U.IEEE;
902 void makeNaN(
bool SNaN,
bool Neg,
const APInt *fill) {
906 void makeLargest(
bool Neg) {
910 void makeSmallest(
bool Neg) {
914 void makeSmallestNormalized(
bool Neg) {
920 : U(std::move(
F), S) {}
924 "Should only compare APFloats with the same semantics");
926 return U.IEEE.compareAbsoluteValue(
RHS.U.IEEE);
928 return U.Double.compareAbsoluteValue(
RHS.U.Double);
936 template <
typename T,
937 typename = std::enable_if_t<std::is_floating_point<T>::value>>
957 Val.makeZero(Negative);
966 Val.makeInf(Negative);
978 APInt intPayload(64, payload);
979 return getQNaN(Sem, Negative, &intPayload);
981 return getQNaN(Sem, Negative,
nullptr);
987 const APInt *payload =
nullptr) {
989 Val.makeNaN(
false, Negative, payload);
995 const APInt *payload =
nullptr) {
997 Val.makeNaN(
true, Negative, payload);
1006 Val.makeLargest(Negative);
1016 Val.makeSmallest(Negative);
1025 bool Negative =
false) {
1027 Val.makeSmallestNormalized(Negative);
1042 "Should only call on two APFloats with the same semantics");
1044 return U.IEEE.add(
RHS.U.IEEE, RM);
1046 return U.Double.add(
RHS.U.Double, RM);
1051 "Should only call on two APFloats with the same semantics");
1053 return U.IEEE.subtract(
RHS.U.IEEE, RM);
1055 return U.Double.subtract(
RHS.U.Double, RM);
1060 "Should only call on two APFloats with the same semantics");
1062 return U.IEEE.multiply(
RHS.U.IEEE, RM);
1064 return U.Double.multiply(
RHS.U.Double, RM);
1069 "Should only call on two APFloats with the same semantics");
1071 return U.IEEE.divide(
RHS.U.IEEE, RM);
1073 return U.Double.divide(
RHS.U.Double, RM);
1078 "Should only call on two APFloats with the same semantics");
1080 return U.IEEE.remainder(
RHS.U.IEEE);
1082 return U.Double.remainder(
RHS.U.Double);
1087 "Should only call on two APFloats with the same semantics");
1089 return U.IEEE.mod(
RHS.U.IEEE);
1091 return U.Double.mod(
RHS.U.Double);
1097 "Should only call on APFloats with the same semantics");
1099 "Should only call on APFloats with the same semantics");
1101 return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
1103 return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
1120 Result.changeSign();
1169 Value.copySign(Sign);
1177 Result.getIEEE().makeQuiet();
1185 bool *IsExact)
const {
1190 bool *IsExact)
const;
1196 unsigned int InputSize,
bool IsSigned,
1202 unsigned int InputSize,
bool IsSigned,
1250 "Should only compare APFloats with the same semantics");
1252 return U.IEEE.compare(
RHS.U.IEEE);
1254 return U.Double.compare(
RHS.U.Double);
1262 return U.IEEE.bitwiseIsEqual(
RHS.U.IEEE);
1264 return U.Double.bitwiseIsEqual(
RHS.U.Double);
1324 unsigned FormatMaxPadding = 3,
bool TruncateZero =
true)
const {
1326 toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero));
1360 if (APFloat::usesLayout<detail::IEEEFloat>(
X.getSemantics()))
1362 if (APFloat::usesLayout<detail::DoubleAPFloat>(
X.getSemantics()))
1372 if (APFloat::usesLayout<detail::IEEEFloat>(
X.getSemantics()))
1374 if (APFloat::usesLayout<detail::DoubleAPFloat>(
X.getSemantics()))
1398 return B <
A ?
B :
A;
1409 return A <
B ?
B :
A;
1420 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1421 return A.isNegative() ?
A :
B;
1422 return B <
A ?
B :
A;
1433 if (
A.isZero() &&
B.isZero() && (
A.isNegative() !=
B.isNegative()))
1434 return A.isNegative() ?
B :
A;
1435 return A <
B ?
B :
A;
1461#undef APFLOAT_DISPATCH_ON_SEMANTICS
#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)
This file implements a class to represent arbitrary precision integral constant values and operations...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
Utilities for dealing with flags related to floating point properties and mode controls.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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)
bool getExactInverse(APFloat *inv) const
APFloat & operator=(APFloat &&RHS)=default
bool isFiniteNonZero() const
APFloat(const APFloat &RHS)=default
void copySign(const APFloat &RHS)
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
APFloat operator+(const APFloat &RHS) const
Add two APFloats, rounding ties to the nearest even.
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 APFloat getAllOnesValue(const fltSemantics &Semantics)
Returns a float which is bitcasted from an all one value int.
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)
opStatus convertFromSignExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
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)
unsigned int convertToHexString(char *DST, unsigned int HexDigits, bool UpperCase, roundingMode RM) const
opStatus multiply(const APFloat &RHS, roundingMode RM)
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.
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)
Expected< opStatus > convertFromString(StringRef, roundingMode)
fltCategory getCategory() const
APFloat(const fltSemantics &Semantics, uninitializedTag)
bool isNegInfinity() const
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)
friend hash_code hash_value(const APFloat &Arg)
See friend declarations above.
static APFloat getNaN(const fltSemantics &Sem, bool Negative=false, uint64_t payload=0)
Factory for NaN values.
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
cmpResult compare(const APFloat &RHS) const
opStatus convertFromZeroExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
bool isSmallestNormalized() const
APFloat(const fltSemantics &Semantics, const APInt &I)
bool operator<=(const APFloat &RHS) const
Class for arbitrary precision integers.
@ 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.
void makeSmallestNormalized(bool Neg)
DoubleAPFloat & operator=(const DoubleAPFloat &RHS)
LLVM_READONLY int getExactLog2() const
opStatus remainder(const DoubleAPFloat &RHS)
opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM)
fltCategory getCategory() const
bool bitwiseIsEqual(const DoubleAPFloat &RHS) const
LLVM_READONLY int getExactLog2Abs() const
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
opStatus convertFromZeroExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
APInt bitcastToAPInt() const
bool getExactInverse(APFloat *inv) const
Expected< opStatus > convertFromString(StringRef, roundingMode)
opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM)
cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
void makeSmallest(bool Neg)
opStatus next(bool nextDown)
friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp, roundingMode)
opStatus divide(const DoubleAPFloat &RHS, roundingMode RM)
friend hash_code hash_value(const DoubleAPFloat &Arg)
bool isSmallestNormalized() const
opStatus mod(const DoubleAPFloat &RHS)
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision, unsigned FormatMaxPadding, bool TruncateZero=true) const
void makeLargest(bool Neg)
cmpResult compare(const DoubleAPFloat &RHS) const
opStatus roundToIntegral(roundingMode RM)
opStatus convertFromSignExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand, const DoubleAPFloat &Addend, roundingMode RM)
unsigned int convertToHexString(char *DST, unsigned int HexDigits, bool UpperCase, roundingMode RM) const
bool needsCleanup() const
opStatus add(const DoubleAPFloat &RHS, roundingMode RM)
friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode)
void makeNaN(bool SNaN, bool Neg, const APInt *fill)
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...
fltCategory getCategory() const
bool isFiniteNonZero() const
opStatus add(const IEEEFloat &, roundingMode)
bool getExactInverse(APFloat *inv) const
If this value has an exact multiplicative inverse, store it in inv and return true.
bool needsCleanup() const
Returns whether this instance allocated memory.
void makeLargest(bool Neg=false)
Make this number the largest magnitude normal number in the given semantics.
LLVM_READONLY int getExactLog2Abs() const
opStatus next(bool nextDown)
IEEE-754R 5.3.1: nextUp/nextDown.
APInt bitcastToAPInt() const
bool isNegative() const
IEEE-754R isSignMinus: Returns true if and only if the current value is negative.
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int, bool, roundingMode)
bool isNaN() const
Returns true if and only if the float is a quiet or signaling NaN.
opStatus convertFromAPInt(const APInt &, bool, roundingMode)
opStatus roundToIntegral(roundingMode)
double convertToDouble() const
float convertToFloat() const
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Converts this value into a decimal string.
cmpResult compareAbsoluteValue(const IEEEFloat &) const
opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode)
void makeSmallest(bool Neg=false)
Make this number the smallest magnitude denormal number in the given semantics.
void makeInf(bool Neg=false)
bool isNormal() const
IEEE-754R isNormal: Returns true if and only if the current value is normal.
friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode)
Expected< opStatus > convertFromString(StringRef, roundingMode)
bool isSmallestNormalized() const
Returns true if this is the smallest (by magnitude) normalized finite number in the given semantics.
bool isLargest() const
Returns true if and only if the number has the largest possible finite magnitude in the current seman...
bool isFinite() const
Returns true if and only if the current value is zero, subnormal, or normal.
void makeNaN(bool SNaN=false, bool Neg=false, const APInt *fill=nullptr)
opStatus convertToInteger(MutableArrayRef< integerPart >, unsigned int, bool, roundingMode, bool *) const
friend int ilogb(const IEEEFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
opStatus remainder(const IEEEFloat &)
IEEE remainder.
friend hash_code hash_value(const IEEEFloat &Arg)
Overload to compute a hash code for an APFloat value.
IEEEFloat & operator=(const IEEEFloat &)
opStatus divide(const IEEEFloat &, roundingMode)
friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode)
Returns: X * 2^Exp for integral exponents.
bool bitwiseIsEqual(const IEEEFloat &) const
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
void makeSmallestNormalized(bool Negative=false)
Returns the smallest (by magnitude) normalized finite number in the given semantics.
bool isInteger() const
Returns true if and only if the number is an exact integer.
cmpResult compare(const IEEEFloat &) const
IEEE comparison with another floating point number (NaNs compare unordered, 0==-0).
opStatus subtract(const IEEEFloat &, roundingMode)
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.
bool isSignaling() const
Returns true if and only if the float is a signaling NaN.
opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int, bool, roundingMode)
bool operator==(const IEEEFloat &) const =delete
The definition of equality is not straightforward for floating point, so we won't use operator==.
void makeZero(bool Neg=false)
LLVM_READONLY int getExactLog2() const
bool isDenormal() const
IEEE-754R isSubnormal(): Returns true if and only if the float is a denormal.
bool isSmallest() const
Returns true if and only if the number has the smallest possible non-zero magnitude in the current se...
opStatus mod(const IEEEFloat &)
C fmod, or llvm frem.
opStatus multiply(const IEEEFloat &, roundingMode)
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.
IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode)
hash_code hash_value(const IEEEFloat &Arg)
IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM)
int ilogb(const IEEEFloat &Arg)
This is an optimization pass for GlobalISel generic memory operations.
hash_code hash_value(const FixedPointSemantics &Val)
APFloat abs(APFloat X)
Returns the absolute value of the argument.
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2018 maximum semantics.
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 maxNum semantics.
lostFraction
Enum that represents what fraction of the LSB truncated bits of an fp number represent.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
RoundingMode
Rounding mode.
@ TowardZero
roundTowardZero.
@ NearestTiesToEven
roundTiesToEven.
@ TowardPositive
roundTowardPositive.
@ NearestTiesToAway
roundTiesToAway.
@ TowardNegative
roundTowardNegative.
APFloat neg(APFloat X)
Returns the negated value of the argument.
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2018 minimum semantics.
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
static const llvm::fltSemantics & EnumToSemantics(Semantics S)
static const fltSemantics & IEEEsingle() LLVM_READNONE
static constexpr roundingMode rmNearestTiesToAway
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
static constexpr roundingMode rmTowardNegative
static ExponentType semanticsMinExponent(const fltSemantics &)
llvm::RoundingMode roundingMode
IEEE-754R 4.3: Rounding-direction attributes.
static constexpr roundingMode rmNearestTiesToEven
static unsigned int semanticsSizeInBits(const fltSemantics &)
static unsigned getSizeInBits(const fltSemantics &Sem)
Returns the size of the floating point number (in bits) in the given semantics.
static const fltSemantics & Float8E4M3FN() LLVM_READNONE
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
static constexpr roundingMode rmTowardZero
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
uninitializedTag
Convenience enum used to construct an uninitialized APFloat.
static const fltSemantics & IEEEquad() LLVM_READNONE
static const fltSemantics & Float8E4M3B11FNUZ() LLVM_READNONE
static const fltSemantics & Bogus() LLVM_READNONE
A Pseudo fltsemantic used to construct APFloats that cannot conflict with anything real.
static ExponentType semanticsMaxExponent(const fltSemantics &)
static unsigned int semanticsPrecision(const fltSemantics &)
static const fltSemantics & IEEEdouble() LLVM_READNONE
static const fltSemantics & Float8E5M2() LLVM_READNONE
static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem)
static constexpr unsigned integerPartWidth
static const fltSemantics & IEEEhalf() LLVM_READNONE
APInt::WordType integerPart
static constexpr roundingMode rmTowardPositive
static bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
static const fltSemantics & Float8E4M3FNUZ() LLVM_READNONE
IlogbErrorKinds
Enumeration of ilogb error results.
static const fltSemantics & BFloat() LLVM_READNONE
static const fltSemantics & FloatTF32() LLVM_READNONE
static const fltSemantics & Float8E5M2FNUZ() LLVM_READNONE
fltCategory
Category of internally-represented number.
opStatus
IEEE-754R 7: Default exception handling.
int32_t ExponentType
A signed type to represent a floating point numbers unbiased exponent.
static unsigned int semanticsIntSizeInBits(const fltSemantics &, bool)