|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/ADT/APFloat.h 38 class APFloat;
include/llvm/CodeGen/GlobalISel/InstructionSelector.h 33 class APFloat;
include/llvm/CodeGen/GlobalISel/Utils.h 39 class APFloat;
include/llvm/Transforms/Utils/FunctionComparator.h 30 class APFloat;
tools/clang/include/clang/Serialization/ASTWriter.h 52 class APFloat;
References
gen/lib/Target/AArch64/AArch64GenDAGISel.inc115097 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
115394 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
115401 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
115408 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
115415 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
115736 APFloat InVal = N->getValueAPF();
115744 APFloat InVal = N->getValueAPF();
115759 APFloat InVal = N->getValueAPF();
115767 APFloat InVal = N->getValueAPF();
gen/lib/Target/AArch64/AArch64GenGlobalISel.inc 23 bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;
797 bool AArch64InstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {
gen/lib/Target/AMDGPU/AMDGPUGenGlobalISel.inc 23 bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;
364 bool AMDGPUInstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {
gen/lib/Target/ARM/ARMGenDAGISel.inc55193 APFloat InVal = N->getValueAPF();
55201 APFloat InVal = N->getValueAPF();
55209 APFloat InVal = N->getValueAPF();
gen/lib/Target/ARM/ARMGenGlobalISel.inc 23 bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;
716 bool ARMInstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {
gen/lib/Target/Mips/MipsGenGlobalISel.inc 23 bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;
602 bool MipsInstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {
gen/lib/Target/NVPTX/NVPTXGenDAGISel.inc72295 return &N->getValueAPF().getSemantics() == &llvm::APFloat::IEEEdouble() &&
72304 return &N->getValueAPF().getSemantics() == &llvm::APFloat::IEEEsingle() &&
gen/lib/Target/RISCV/RISCVGenGlobalISel.inc 23 bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;
248 bool RISCVInstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {
gen/lib/Target/X86/X86GenDAGISel.inc254444 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
254451 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
254458 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
254465 const APFloat & Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
gen/lib/Target/X86/X86GenGlobalISel.inc 23 bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;
711 bool X86InstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {
include/llvm/ADT/APFloat.h 434 bool getExactInverse(APFloat *inv) const;
592 std::unique_ptr<APFloat[]> Floats;
594 opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
594 opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
594 opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
595 const APFloat &cc, roundingMode RM);
605 DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second);
605 DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second);
621 APFloat &getFirst() { return Floats[0]; }
622 const APFloat &getFirst() const { return Floats[0]; }
623 APFloat &getSecond() { return Floats[1]; }
624 const APFloat &getSecond() const { return Floats[1]; }
675 bool getExactInverse(APFloat *inv) const;
840 cmpResult compareAbsoluteValue(const APFloat &RHS) const {
860 APFloat(const APFloat &RHS) = default;
861 APFloat(APFloat &&RHS) = default;
870 static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
871 APFloat Val(Sem, uninitialized);
879 static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
880 APFloat Val(Sem, uninitialized);
890 static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
901 static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
903 APFloat Val(Sem, uninitialized);
909 static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
911 APFloat Val(Sem, uninitialized);
919 static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) {
920 APFloat Val(Sem, uninitialized);
929 static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) {
930 APFloat Val(Sem, uninitialized);
939 static APFloat getSmallestNormalized(const fltSemantics &Sem,
941 APFloat Val(Sem, uninitialized);
950 static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
956 opStatus add(const APFloat &RHS, roundingMode RM) {
965 opStatus subtract(const APFloat &RHS, roundingMode RM) {
974 opStatus multiply(const APFloat &RHS, roundingMode RM) {
983 opStatus divide(const APFloat &RHS, roundingMode RM) {
992 opStatus remainder(const APFloat &RHS) {
1001 opStatus mod(const APFloat &RHS) {
1010 opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
1010 opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
1035 APFloat operator+(const APFloat &RHS) const {
1035 APFloat operator+(const APFloat &RHS) const {
1036 APFloat Result(*this);
1043 APFloat operator-(const APFloat &RHS) const {
1043 APFloat operator-(const APFloat &RHS) const {
1044 APFloat Result(*this);
1051 APFloat operator*(const APFloat &RHS) const {
1051 APFloat operator*(const APFloat &RHS) const {
1052 APFloat Result(*this);
1059 APFloat operator/(const APFloat &RHS) const {
1059 APFloat operator/(const APFloat &RHS) const {
1060 APFloat Result(*this);
1070 void copySign(const APFloat &RHS) {
1077 static APFloat copySign(APFloat Value, const APFloat &Sign) {
1077 static APFloat copySign(APFloat Value, const APFloat &Sign) {
1077 static APFloat copySign(APFloat Value, const APFloat &Sign) {
1115 bool operator==(const APFloat &) const = delete;
1117 cmpResult compare(const APFloat &RHS) const {
1127 bool bitwiseIsEqual(const APFloat &RHS) const {
1147 APFloat Tmp(V);
1148 Tmp.convert(getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
1179 APFloat &operator=(const APFloat &RHS) = default;
1179 APFloat &operator=(const APFloat &RHS) = default;
1180 APFloat &operator=(APFloat &&RHS) = default;
1180 APFloat &operator=(APFloat &&RHS) = default;
1191 bool getExactInverse(APFloat *inv) const {
1195 friend hash_code hash_value(const APFloat &Arg);
1196 friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
1197 friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
1197 friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
1198 friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
1198 friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
1207 hash_code hash_value(const APFloat &Arg);
1208 inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
1208 inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
1208 inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
1209 if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
1211 if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
1220 inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
1220 inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
1220 inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
1221 if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
1223 if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
1228 inline APFloat abs(APFloat X) {
1228 inline APFloat abs(APFloat X) {
1234 inline APFloat neg(APFloat X) {
1234 inline APFloat neg(APFloat X) {
1242 inline APFloat minnum(const APFloat &A, const APFloat &B) {
1242 inline APFloat minnum(const APFloat &A, const APFloat &B) {
1242 inline APFloat minnum(const APFloat &A, const APFloat &B) {
1247 return (B.compare(A) == APFloat::cmpLessThan) ? B : A;
1253 inline APFloat maxnum(const APFloat &A, const APFloat &B) {
1253 inline APFloat maxnum(const APFloat &A, const APFloat &B) {
1253 inline APFloat maxnum(const APFloat &A, const APFloat &B) {
1258 return (A.compare(B) == APFloat::cmpLessThan) ? B : A;
1264 inline APFloat minimum(const APFloat &A, const APFloat &B) {
1264 inline APFloat minimum(const APFloat &A, const APFloat &B) {
1264 inline APFloat minimum(const APFloat &A, const APFloat &B) {
1271 return (B.compare(A) == APFloat::cmpLessThan) ? B : A;
1277 inline APFloat maximum(const APFloat &A, const APFloat &B) {
1277 inline APFloat maximum(const APFloat &A, const APFloat &B) {
1277 inline APFloat maximum(const APFloat &A, const APFloat &B) {
1284 return (A.compare(B) == APFloat::cmpLessThan) ? B : A;
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
43 KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
44 const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
65 using key_type = KeyT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
121 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
122 if (is_trivially_copyable<KeyT>::value &&
145 size_type count(const_arg_type_t<KeyT> Val) const {
150 iterator find(const_arg_type_t<KeyT> Val) {
156 const_iterator find(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
210 std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
229 std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
272 bool erase(const KeyT &Val) {
291 value_type& FindAndConstruct(const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
303 value_type& FindAndConstruct(KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
334 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
349 const KeyT EmptyKey = getEmptyKey();
351 ::new (&B->getFirst()) KeyT(EmptyKey);
369 const KeyT EmptyKey = getEmptyKey();
370 const KeyT TombstoneKey = getTombstoneKey();
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
414 static unsigned getHashValue(const KeyT &Val) {
419 static unsigned getHashValue(const LookupKeyT &Val) {
423 static const KeyT getEmptyKey() {
429 static const KeyT getTombstoneKey() {
515 BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
525 BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
566 const KeyT EmptyKey = getEmptyKey();
578 bool LookupBucketFor(const LookupKeyT &Val,
590 const KeyT EmptyKey = getEmptyKey();
591 const KeyT TombstoneKey = getTombstoneKey();
629 bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
include/llvm/CodeGen/GlobalISel/InstructionSelector.h 468 virtual bool testImmPredicate_APFloat(unsigned, const APFloat &) const {
include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h 298 APFloat Value = State.MIs[InsnID]->getOperand(1).getFPImm()->getValueAPF();
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h 699 MachineInstrBuilder buildFConstant(const DstOp &Res, const APFloat &Val);
include/llvm/CodeGen/GlobalISel/Utils.h 148 APFloat getAPFloatFromSize(double Val, unsigned Size);
include/llvm/CodeGen/SelectionDAG.h 624 SDValue getConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT,
631 SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT) {
1383 case MVT::f16: return APFloat::IEEEhalf();
1384 case MVT::f32: return APFloat::IEEEsingle();
1385 case MVT::f64: return APFloat::IEEEdouble();
1386 case MVT::f80: return APFloat::x87DoubleExtended();
1387 case MVT::f128: return APFloat::IEEEquad();
1388 case MVT::ppcf128: return APFloat::PPCDoubleDouble();
include/llvm/CodeGen/SelectionDAGNodes.h 1625 const APFloat& getValueAPF() const { return Value->getValueAPF(); }
1651 bool isExactlyValue(const APFloat& V) const;
1653 static bool isValueValidForType(EVT VT, const APFloat& Val);
include/llvm/CodeGen/TargetLowering.h 862 virtual bool isFPImmLegal(const APFloat & /*Imm*/, EVT /*VT*/,
include/llvm/IR/Constants.h 266 APFloat Val;
268 ConstantFP(Type *Ty, const APFloat& V);
288 static Constant *get(Type *Ty, const APFloat &V);
291 static ConstantFP *get(LLVMContext &Context, const APFloat &V);
301 static bool isValueValidForType(Type *Ty, const APFloat &V);
302 inline const APFloat &getValueAPF() const { return Val; }
322 bool isExactlyValue(const APFloat &V) const;
326 APFloat FV(V);
327 FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
615 APFloat getElementAsAPFloat(unsigned i) const;
include/llvm/IR/PatternMatch.h 175 const APFloat *&Res;
176 apfloat_match(const APFloat *&R) : Res(R) {}
198 inline apfloat_match m_APFloat(const APFloat *&Res) { return Res; }
502 bool isValue(const APFloat &C) { return C.isNaN(); }
511 bool isValue(const APFloat &C) { return C.isZero(); }
520 bool isValue(const APFloat &C) { return C.isPosZero(); }
529 bool isValue(const APFloat &C) { return C.isNegZero(); }
include/llvm/IR/Type.h 171 case HalfTyID: return APFloat::IEEEhalf();
172 case FloatTyID: return APFloat::IEEEsingle();
173 case DoubleTyID: return APFloat::IEEEdouble();
174 case X86_FP80TyID: return APFloat::x87DoubleExtended();
175 case FP128TyID: return APFloat::IEEEquad();
176 case PPC_FP128TyID: return APFloat::PPCDoubleDouble();
include/llvm/Support/AlignOf.h 24 T t;
25 AlignerImpl<Ts...> rest;
30 T t;
35 char arr[sizeof(T)];
36 SizerImpl<Ts...> rest;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/SMTAPI.h 409 virtual SMTExprRef mkFloat(const llvm::APFloat Float) = 0;
419 llvm::APFloat &Float) = 0;
include/llvm/Support/type_traits.h 31 using UnderlyingT = typename std::remove_reference<T>::type;
65 using type = const T &;
91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
include/llvm/Transforms/Utils/FunctionComparator.h 324 int cmpAPFloats(const APFloat &L, const APFloat &R) const;
324 int cmpAPFloats(const APFloat &L, const APFloat &R) const;
lib/Analysis/ConstantFolding.cpp 130 APFloat FP(DestTy->getFltSemantics(), Result);
1564 APFloat APF(V);
1566 APF.convert(Ty->getFltSemantics(), APFloat::rmNearestTiesToEven, &unused);
1624 Constant *ConstantFoldSSEConvertToInt(const APFloat &Val, bool roundTowardZero,
1633 APFloat::roundingMode mode = roundTowardZero? APFloat::rmTowardZero
1633 APFloat::roundingMode mode = roundTowardZero? APFloat::rmTowardZero
1634 : APFloat::rmNearestTiesToEven;
1635 APFloat::opStatus status =
1638 if (status != APFloat::opOK &&
1639 (!roundTowardZero || status != APFloat::opInexact))
1654 APFloat APF = Op->getValueAPF();
1655 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &unused);
1655 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &unused);
1733 APFloat Val(Op->getValueAPF());
1736 Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &lost);
1736 Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &lost);
1745 APFloat U = Op->getValueAPF();
1748 U.roundToIntegral(APFloat::rmNearestTiesToEven);
1753 U.roundToIntegral(APFloat::rmNearestTiesToAway);
1758 U.roundToIntegral(APFloat::rmTowardPositive);
1763 U.roundToIntegral(APFloat::rmTowardNegative);
1768 U.roundToIntegral(APFloat::rmTowardZero);
1842 U.roundToIntegral(APFloat::rmTowardPositive);
1883 U.roundToIntegral(APFloat::rmTowardNegative);
1915 U.roundToIntegral(APFloat::rmNearestTiesToEven);
1922 U.roundToIntegral(APFloat::rmNearestTiesToAway);
1956 U.roundToIntegral(APFloat::rmTowardZero);
1973 APFloat Val(APFloat::IEEEhalf(), Op->getValue());
1973 APFloat Val(APFloat::IEEEhalf(), Op->getValue());
1976 APFloat::opStatus status = Val.convert(
1977 Ty->getFltSemantics(), APFloat::rmNearestTiesToEven, &lost);
2045 APFloat V1 = Op1->getValueAPF();
2046 const APFloat &V2 = Op2->getValueAPF();
2052 const APFloat &C1 = Op1->getValueAPF();
2053 const APFloat &C2 = Op2->getValueAPF();
2058 const APFloat &C1 = Op1->getValueAPF();
2059 const APFloat &C2 = Op2->getValueAPF();
2064 const APFloat &C1 = Op1->getValueAPF();
2065 const APFloat &C2 = Op2->getValueAPF();
2070 const APFloat &C1 = Op1->getValueAPF();
2071 const APFloat &C2 = Op2->getValueAPF();
2093 APFloat V = Op1->getValueAPF();
2094 if (APFloat::opStatus::opOK == V.mod(Op2->getValueAPF()))
2291 APFloat V = Op1->getValueAPF();
2293 APFloat::rmNearestTiesToEven);
2503 const APFloat &Op = OpC->getValueAPF();
2521 return Op.compare(APFloat(-745.0)) != APFloat::cmpLessThan &&
2522 Op.compare(APFloat(709.0)) != APFloat::cmpGreaterThan;
2524 return Op.compare(APFloat(-103.0f)) != APFloat::cmpLessThan &&
2525 Op.compare(APFloat(88.0f)) != APFloat::cmpGreaterThan;
2533 return Op.compare(APFloat(-1074.0)) != APFloat::cmpLessThan &&
2534 Op.compare(APFloat(1023.0)) != APFloat::cmpGreaterThan;
2536 return Op.compare(APFloat(-149.0f)) != APFloat::cmpLessThan &&
2537 Op.compare(APFloat(127.0f)) != APFloat::cmpGreaterThan;
2568 APFloat::cmpLessThan &&
2570 APFloat::cmpGreaterThan;
2580 return Op.compare(APFloat(-710.0)) != APFloat::cmpLessThan &&
2581 Op.compare(APFloat(710.0)) != APFloat::cmpGreaterThan;
2583 return Op.compare(APFloat(-89.0f)) != APFloat::cmpLessThan &&
2584 Op.compare(APFloat(89.0f)) != APFloat::cmpGreaterThan;
2604 const APFloat &Op0 = Op0C->getValueAPF();
2605 const APFloat &Op1 = Op1C->getValueAPF();
lib/Analysis/InstructionSimplify.cpp 3529 const APFloat *C;
3582 const APFloat *C2;
3584 C2->compare(*C) == APFloat::cmpLessThan) ||
3586 C2->compare(*C) == APFloat::cmpGreaterThan)) {
3915 const APFloat *C;
5120 const APFloat *C;
lib/Analysis/ValueTracking.cpp 4502 const APFloat *FC1;
4506 const APFloat *FC2;
4515 FC1->compare(*FC2) == APFloat::cmpResult::cmpLessThan)
4525 FC1->compare(*FC2) == APFloat::cmpResult::cmpGreaterThan)
lib/AsmParser/LLLexer.cpp 1004 APFloatVal = APFloat(APFloat::IEEEdouble(),
1015 APFloatVal = APFloat(APFloat::x87DoubleExtended(), APInt(80, Pair));
1020 APFloatVal = APFloat(APFloat::IEEEquad(), APInt(128, Pair));
1025 APFloatVal = APFloat(APFloat::PPCDoubleDouble(), APInt(128, Pair));
1028 APFloatVal = APFloat(APFloat::IEEEhalf(),
1105 APFloatVal = APFloat(APFloat::IEEEdouble(),
1142 APFloatVal = APFloat(APFloat::IEEEdouble(),
lib/AsmParser/LLLexer.h 41 APFloat APFloatVal;
63 const APFloat &getAPFloatVal() const { return APFloatVal; }
lib/AsmParser/LLParser.cpp 5174 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
5177 ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5177 ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5180 ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
5180 ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
lib/AsmParser/LLParser.h 65 APFloat APFloatVal{0.0};
lib/Bitcode/Reader/BitcodeReader.cpp 2403 V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf(),
2406 V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle(),
2409 V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble(),
2416 V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended(),
2419 V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad(),
2422 V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble(),
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 860 APFloat APF = APFloat(MI->getOperand(0).getFPImm()->getValueAPF());
869 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
869 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
2323 static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP);
2473 static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) {
lib/CodeGen/AsmPrinter/DwarfUnit.cpp 513 APFloat FPImm = MO.getFPImm()->getValueAPF();
lib/CodeGen/GlobalISel/LegalizerHelper.cpp 1689 APFloat Val = SrcMO.getFPImm()->getValueAPF();
1693 Val.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
1693 Val.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
1697 Val.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
1697 Val.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
3923 APFloat TwoPExpFP(SrcTy.getSizeInBits() == 32 ? APFloat::IEEEsingle()
3923 APFloat TwoPExpFP(SrcTy.getSizeInBits() == 32 ? APFloat::IEEEsingle()
3924 : APFloat::IEEEdouble(),
3926 TwoPExpFP.convertFromAPInt(TwoPExpInt, false, APFloat::rmNearestTiesToEven);
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp 355 const APFloat &Val) {
lib/CodeGen/GlobalISel/Utils.cpp 325 APFloat llvm::getAPFloatFromSize(double Val, unsigned Size) {
333 APFloat APF(Val);
334 APF.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
334 APF.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
lib/CodeGen/MachineVerifier.cpp 999 if (APFloat::getSizeInBits(CF->getValueAPF().getSemantics()) !=
lib/CodeGen/SelectionDAG/DAGCombiner.cpp12542 const APFloat &N1APF = N1CFP->getValueAPF();
12543 APFloat Recip(N1APF.getSemantics(), 1); // 1.0
12544 APFloat::opStatus st = Recip.divide(N1APF, APFloat::rmNearestTiesToEven);
12544 APFloat::opStatus st = Recip.divide(N1APF, APFloat::rmNearestTiesToEven);
12547 if ((st == APFloat::opOK || st == APFloat::opInexact) && // Not too nasty
12547 if ((st == APFloat::opOK || st == APFloat::opInexact) && // Not too nasty
12676 const APFloat &V = N1C->getValueAPF();
12959 if (APFloat::semanticsPrecision(sem) >= ActualSize) {
13200 APFloat CVal = CFP1->getValueAPF();
13216 APFloat (*Op)(const APFloat &, const APFloat &)) {
13216 APFloat (*Op)(const APFloat &, const APFloat &)) {
13216 APFloat (*Op)(const APFloat &, const APFloat &)) {
13224 const APFloat &C0 = N0CFP->getValueAPF();
13225 const APFloat &C1 = N1CFP->getValueAPF();
20446 APFloat SmallestNorm = APFloat::getSmallestNormalized(FltSem);
20446 APFloat SmallestNorm = APFloat::getSmallestNormalized(FltSem);
lib/CodeGen/SelectionDAG/FastISel.cpp 424 const APFloat &Flt = CF->getValueAPF();
429 (void)Flt.convertToInteger(SIntVal, APFloat::rmTowardZero, &isExact);
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 307 APFloat APF = CFP->getValueAPF();
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp 1609 DAG.getConstantFP(APFloat(APFloat::PPCDoubleDouble(),
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 3989 if (APFloat::semanticsPrecision(sem) >= SrcVT.getSizeInBits()-1 &&
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 114 bool ConstantFPSDNode::isExactlyValue(const APFloat& V) const {
119 const APFloat& Val) {
123 APFloat Val2 = APFloat(Val);
126 APFloat::rmNearestTiesToEven,
1301 SDValue SelectionDAG::getConstantFP(const APFloat &V, const SDLoc &DL, EVT VT,
1348 APFloat APF = APFloat(Val);
1349 APF.convert(EVTToAPFloatSemantics(EltVT), APFloat::rmNearestTiesToEven,
2039 APFloat::cmpResult R = N1CFP->getValueAPF().compare(N2CFP->getValueAPF());
2042 case ISD::SETEQ: if (R==APFloat::cmpUnordered)
2045 case ISD::SETOEQ: return getBoolConstant(R==APFloat::cmpEqual, dl, VT,
2047 case ISD::SETNE: if (R==APFloat::cmpUnordered)
2050 case ISD::SETONE: return getBoolConstant(R==APFloat::cmpGreaterThan ||
2051 R==APFloat::cmpLessThan, dl, VT,
2053 case ISD::SETLT: if (R==APFloat::cmpUnordered)
2056 case ISD::SETOLT: return getBoolConstant(R==APFloat::cmpLessThan, dl, VT,
2058 case ISD::SETGT: if (R==APFloat::cmpUnordered)
2061 case ISD::SETOGT: return getBoolConstant(R==APFloat::cmpGreaterThan, dl,
2063 case ISD::SETLE: if (R==APFloat::cmpUnordered)
2066 case ISD::SETOLE: return getBoolConstant(R==APFloat::cmpLessThan ||
2067 R==APFloat::cmpEqual, dl, VT,
2069 case ISD::SETGE: if (R==APFloat::cmpUnordered)
2072 case ISD::SETOGE: return getBoolConstant(R==APFloat::cmpGreaterThan ||
2073 R==APFloat::cmpEqual, dl, VT, OpVT);
2074 case ISD::SETO: return getBoolConstant(R!=APFloat::cmpUnordered, dl, VT,
2076 case ISD::SETUO: return getBoolConstant(R==APFloat::cmpUnordered, dl, VT,
2078 case ISD::SETUEQ: return getBoolConstant(R==APFloat::cmpUnordered ||
2079 R==APFloat::cmpEqual, dl, VT,
2081 case ISD::SETUNE: return getBoolConstant(R!=APFloat::cmpEqual, dl, VT,
2083 case ISD::SETULT: return getBoolConstant(R==APFloat::cmpUnordered ||
2084 R==APFloat::cmpLessThan, dl, VT,
2086 case ISD::SETUGT: return getBoolConstant(R==APFloat::cmpGreaterThan ||
2087 R==APFloat::cmpUnordered, dl, VT,
2089 case ISD::SETULE: return getBoolConstant(R!=APFloat::cmpGreaterThan, dl,
2091 case ISD::SETUGE: return getBoolConstant(R!=APFloat::cmpLessThan, dl, VT,
4303 APFloat apf(EVTToAPFloatSemantics(VT),
4307 APFloat::rmNearestTiesToEven);
4312 return getConstantFP(APFloat(APFloat::IEEEhalf(), Val), DL, VT);
4314 return getConstantFP(APFloat(APFloat::IEEEsingle(), Val), DL, VT);
4316 return getConstantFP(APFloat(APFloat::IEEEdouble(), Val), DL, VT);
4318 return getConstantFP(APFloat(APFloat::IEEEquad(), Val), DL, VT);
4342 APFloat FPV(APFloat::IEEEhalf(),
4342 APFloat FPV(APFloat::IEEEhalf(),
4348 APFloat::rmNearestTiesToEven, &Ignored);
4356 APFloat V = C->getValueAPF(); // make copy
4365 APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardPositive);
4365 APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardPositive);
4366 if (fs == APFloat::opOK || fs == APFloat::opInexact)
4366 if (fs == APFloat::opOK || fs == APFloat::opInexact)
4371 APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardZero);
4371 APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardZero);
4372 if (fs == APFloat::opOK || fs == APFloat::opInexact)
4372 if (fs == APFloat::opOK || fs == APFloat::opInexact)
4377 APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardNegative);
4377 APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardNegative);
4378 if (fs == APFloat::opOK || fs == APFloat::opInexact)
4378 if (fs == APFloat::opOK || fs == APFloat::opInexact)
4387 APFloat::rmNearestTiesToEven, &ignored);
4395 APFloat::opStatus s =
4396 V.convertToInteger(IntVal, APFloat::rmTowardZero, &ignored);
4397 if (s == APFloat::opInvalidOp) // inexact is OK, in fact usual
4413 (void)V.convert(APFloat::IEEEhalf(),
4414 APFloat::rmNearestTiesToEven, &Ignored);
4987 APFloat C1 = N1CFP->getValueAPF(), C2 = N2CFP->getValueAPF();
4990 C1.add(C2, APFloat::rmNearestTiesToEven);
4993 C1.subtract(C2, APFloat::rmNearestTiesToEven);
4996 C1.multiply(C2, APFloat::rmNearestTiesToEven);
4999 C1.divide(C2, APFloat::rmNearestTiesToEven);
5011 APFloat C1 = N1CFP->getValueAPF(); // make copy
5015 (void) C1.convert(EVTToAPFloatSemantics(VT), APFloat::rmNearestTiesToEven,
5031 return getConstantFP(APFloat::getNaN(EVTToAPFloatSemantics(VT)), DL, VT);
5458 APFloat V1 = N1CFP->getValueAPF();
5459 const APFloat &V2 = N2CFP->getValueAPF();
5460 const APFloat &V3 = N3CFP->getValueAPF();
5461 V1.fusedMultiplyAdd(V2, V3, APFloat::rmNearestTiesToEven);
9497 const APFloat &APF = CN->getValueAPF();
9498 if (APF.convertToInteger(IntVal, APFloat::rmTowardZero, &IsExact) !=
9499 APFloat::opOK ||
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 4892 return DAG.getConstantFP(APFloat(APFloat::IEEEsingle(), APInt(32, Flt)), dl,
5314 APFloat Ten(10.0f);
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp 571 if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEsingle())
573 else if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEdouble())
lib/CodeGen/SelectionDAG/TargetLowering.cpp 5472 APFloat V = cast<ConstantFPSDNode>(Op)->getValueAPF();
5483 APFloat V = cast<ConstantFPSDNode>(C)->getValueAPF();
5972 APFloat APF(APFSem, APInt::getNullValue(SrcVT.getScalarSizeInBits()));
5974 if (APFloat::opOverflow &
5975 APF.convertFromAPInt(SignMask, false, APFloat::rmNearestTiesToEven)) {
lib/ExecutionEngine/ExecutionEngine.cpp 693 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended());
693 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended());
693 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended());
696 APFloat::rmNearestTiesToEven);
708 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended());
708 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended());
708 APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended());
711 APFloat::rmNearestTiesToEven);
725 APFloat apf = APFloat(APFloat::x87DoubleExtended(), GV.IntVal);
725 APFloat apf = APFloat(APFloat::x87DoubleExtended(), GV.IntVal);
730 APFloat::rmTowardZero, &ignored);
845 APFloat apfLHS = APFloat(Sem, LHS.IntVal);
849 apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven);
854 APFloat::rmNearestTiesToEven);
859 APFloat::rmNearestTiesToEven);
864 APFloat::rmNearestTiesToEven);
lib/FuzzMutate/OpDescriptor.cpp 26 Cs.push_back(ConstantFP::get(Ctx, APFloat::getZero(Sem)));
27 Cs.push_back(ConstantFP::get(Ctx, APFloat::getLargest(Sem)));
28 Cs.push_back(ConstantFP::get(Ctx, APFloat::getSmallest(Sem)));
lib/IR/AsmWriter.cpp 1303 const APFloat &APF = CFP->getValueAPF();
1304 if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
1305 &APF.getSemantics() == &APFloat::IEEEdouble()) {
1312 bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
1328 if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1339 APFloat apf = APF;
1342 apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
1342 apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
1353 if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
1360 } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
1366 } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
1372 } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
lib/IR/ConstantFold.cpp 596 APFloat Val = FPC->getValueAPF();
597 Val.convert(DestTy->isHalfTy() ? APFloat::IEEEhalf() :
598 DestTy->isFloatTy() ? APFloat::IEEEsingle() :
599 DestTy->isDoubleTy() ? APFloat::IEEEdouble() :
600 DestTy->isX86_FP80Ty() ? APFloat::x87DoubleExtended() :
601 DestTy->isFP128Ty() ? APFloat::IEEEquad() :
602 DestTy->isPPC_FP128Ty() ? APFloat::PPCDoubleDouble() :
603 APFloat::Bogus(),
604 APFloat::rmNearestTiesToEven, &ignored);
611 const APFloat &V = FPC->getValueAPF();
615 if (APFloat::opInvalidOp ==
616 V.convertToInteger(IntVal, APFloat::rmTowardZero, &ignored)) {
685 APFloat apf(DestTy->getFltSemantics(),
688 APFloat::rmNearestTiesToEven);
962 const APFloat &CV = CFP->getValueAPF();
1284 const APFloat &C1V = CFP1->getValueAPF();
1285 const APFloat &C2V = CFP2->getValueAPF();
1286 APFloat C3V = C1V; // copy for modification
1291 (void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
1294 (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
1297 (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
1300 (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
1878 const APFloat &C1V = cast<ConstantFP>(C1)->getValueAPF();
1879 const APFloat &C2V = cast<ConstantFP>(C2)->getValueAPF();
1880 APFloat::cmpResult R = C1V.compare(C2V);
1886 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered);
1888 return ConstantInt::get(ResultTy, R!=APFloat::cmpUnordered);
1890 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1891 R==APFloat::cmpEqual);
1893 return ConstantInt::get(ResultTy, R==APFloat::cmpEqual);
1895 return ConstantInt::get(ResultTy, R!=APFloat::cmpEqual);
1897 return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1898 R==APFloat::cmpGreaterThan);
1900 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1901 R==APFloat::cmpLessThan);
1903 return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan);
1905 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1906 R==APFloat::cmpGreaterThan);
1908 return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan);
1910 return ConstantInt::get(ResultTy, R!=APFloat::cmpGreaterThan);
1912 return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1913 R==APFloat::cmpEqual);
1915 return ConstantInt::get(ResultTy, R!=APFloat::cmpLessThan);
1917 return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan ||
1918 R==APFloat::cmpEqual);
lib/IR/Constants.cpp 295 APFloat::getZero(APFloat::IEEEhalf()));
295 APFloat::getZero(APFloat::IEEEhalf()));
298 APFloat::getZero(APFloat::IEEEsingle()));
298 APFloat::getZero(APFloat::IEEEsingle()));
301 APFloat::getZero(APFloat::IEEEdouble()));
301 APFloat::getZero(APFloat::IEEEdouble()));
304 APFloat::getZero(APFloat::x87DoubleExtended()));
304 APFloat::getZero(APFloat::x87DoubleExtended()));
307 APFloat::getZero(APFloat::IEEEquad()));
307 APFloat::getZero(APFloat::IEEEquad()));
310 APFloat(APFloat::PPCDoubleDouble(),
349 APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(),
349 APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(),
702 return &APFloat::IEEEhalf();
704 return &APFloat::IEEEsingle();
706 return &APFloat::IEEEdouble();
708 return &APFloat::x87DoubleExtended();
710 return &APFloat::IEEEquad();
713 return &APFloat::PPCDoubleDouble();
719 APFloat FV(V);
722 APFloat::rmNearestTiesToEven, &ignored);
732 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
747 APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
759 APFloat NaN = APFloat::getNaN(Semantics, Negative, Payload);
759 APFloat NaN = APFloat::getNaN(Semantics, Negative, Payload);
770 APFloat NaN = APFloat::getQNaN(Semantics, Negative, Payload);
770 APFloat NaN = APFloat::getQNaN(Semantics, Negative, Payload);
781 APFloat NaN = APFloat::getSNaN(Semantics, Negative, Payload);
781 APFloat NaN = APFloat::getSNaN(Semantics, Negative, Payload);
792 APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true);
792 APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true);
811 ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) {
818 if (&V.getSemantics() == &APFloat::IEEEhalf())
820 else if (&V.getSemantics() == &APFloat::IEEEsingle())
822 else if (&V.getSemantics() == &APFloat::IEEEdouble())
824 else if (&V.getSemantics() == &APFloat::x87DoubleExtended())
826 else if (&V.getSemantics() == &APFloat::IEEEquad())
841 Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
849 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
855 bool ConstantFP::isExactlyValue(const APFloat &V) const {
1312 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
1314 APFloat Val2 = APFloat(Val);
1322 if (&Val2.getSemantics() == &APFloat::IEEEhalf())
1324 Val2.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &losesInfo);
1324 Val2.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &losesInfo);
1328 if (&Val2.getSemantics() == &APFloat::IEEEsingle())
1330 Val2.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1330 Val2.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1334 if (&Val2.getSemantics() == &APFloat::IEEEhalf() ||
1335 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1336 &Val2.getSemantics() == &APFloat::IEEEdouble())
1338 Val2.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1338 Val2.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1342 return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1343 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1344 &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1345 &Val2.getSemantics() == &APFloat::x87DoubleExtended();
1347 return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1348 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1349 &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1350 &Val2.getSemantics() == &APFloat::IEEEquad();
1352 return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1353 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1354 &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1355 &Val2.getSemantics() == &APFloat::PPCDoubleDouble();
2740 APFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const {
2748 return APFloat(APFloat::IEEEhalf(), APInt(16, EltVal));
2752 return APFloat(APFloat::IEEEsingle(), APInt(32, EltVal));
2756 return APFloat(APFloat::IEEEdouble(), APInt(64, EltVal));
lib/IR/Core.cpp 1360 APFloat APF = cFP->getValueAPF();
1361 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
1361 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
lib/IR/LLVMContextImpl.h 85 static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
85 static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
86 static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus(), 2); }
86 static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus(), 2); }
88 static unsigned getHashValue(const APFloat &Key) {
92 static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
92 static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
1265 DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>;
lib/IR/Metadata.cpp 933 APFloat AVal = mdconst::extract<ConstantFP>(A->getOperand(0))->getValueAPF();
934 APFloat BVal = mdconst::extract<ConstantFP>(B->getOperand(0))->getValueAPF();
935 if (AVal.compare(BVal) == APFloat::cmpLessThan)
lib/IR/Verifier.cpp 4165 const APFloat &Accuracy = CFP0->getValueAPF();
lib/MC/MCParser/AsmParser.cpp 1218 APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
1218 APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
1971 return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle());
1974 return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble());
2166 return parseDirectiveRealDCB(IDVal, APFloat::IEEEdouble());
2170 return parseDirectiveRealDCB(IDVal, APFloat::IEEEsingle());
3132 APFloat Value(Semantics);
3136 Value = APFloat::getInf(Semantics);
3138 Value = APFloat::getNaN(Semantics, false, ~0);
3141 } else if (Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven) ==
3142 APFloat::opInvalidOp)
lib/Support/APFloat.cpp 136 if (&Sem == &llvm::APFloat::IEEEhalf())
138 else if (&Sem == &llvm::APFloat::IEEEsingle())
140 else if (&Sem == &llvm::APFloat::IEEEdouble())
142 else if (&Sem == &llvm::APFloat::x87DoubleExtended())
144 else if (&Sem == &llvm::APFloat::IEEEquad())
146 else if (&Sem == &llvm::APFloat::PPCDoubleDouble())
3650 bool IEEEFloat::getExactInverse(APFloat *inv) const {
3887 Floats(new APFloat[2]{APFloat(semIEEEdouble), APFloat(semIEEEdouble)}) {
3893 Floats(new APFloat[2]{APFloat(semIEEEdouble, uninitialized),
3899 : Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
3906 Floats(new APFloat[2]{
3912 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
3913 APFloat &&Second)
3915 Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
3923 Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
3949 APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
3949 APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
3949 APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
3950 const APFloat &c, const APFloat &cc,
3950 const APFloat &c, const APFloat &cc,
3953 APFloat z = a;
3965 if (AComparedToC == APFloat::cmpGreaterThan) {
3980 APFloat zz = aa;
3982 if (AComparedToC == APFloat::cmpGreaterThan) {
3997 APFloat q = a;
4002 auto zz = q;
4028 APFloat::opStatus DoubleAPFloat::addWithSpecial(const DoubleAPFloat &LHS,
4063 APFloat A(LHS.Floats[0]), AA(LHS.Floats[1]), C(RHS.Floats[0]),
4074 APFloat::opStatus DoubleAPFloat::add(const DoubleAPFloat &RHS,
4079 APFloat::opStatus DoubleAPFloat::subtract(const DoubleAPFloat &RHS,
4087 APFloat::opStatus DoubleAPFloat::multiply(const DoubleAPFloat &RHS,
4088 APFloat::roundingMode RM) {
4131 APFloat A = Floats[0], B = Floats[1], C = RHS.Floats[0], D = RHS.Floats[1];
4133 APFloat T = A;
4142 APFloat Tau = A;
4148 APFloat V = A;
4151 APFloat W = B;
4158 APFloat U = T;
4173 APFloat::opStatus DoubleAPFloat::divide(const DoubleAPFloat &RHS,
4174 APFloat::roundingMode RM) {
4176 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4183 APFloat::opStatus DoubleAPFloat::remainder(const DoubleAPFloat &RHS) {
4185 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4192 APFloat::opStatus DoubleAPFloat::mod(const DoubleAPFloat &RHS) {
4194 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4200 APFloat::opStatus
4203 APFloat::roundingMode RM) {
4205 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4213 APFloat::opStatus DoubleAPFloat::roundToIntegral(APFloat::roundingMode RM) {
4213 APFloat::opStatus DoubleAPFloat::roundToIntegral(APFloat::roundingMode RM) {
4215 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4226 APFloat::cmpResult
4247 APFloat::fltCategory DoubleAPFloat::getCategory() const {
4290 APFloat::cmpResult DoubleAPFloat::compare(const DoubleAPFloat &RHS) const {
4293 if (Result == APFloat::cmpEqual)
4318 APFloat::opStatus DoubleAPFloat::convertFromString(StringRef S,
4321 APFloat Tmp(semPPCDoubleDoubleLegacy);
4327 APFloat::opStatus DoubleAPFloat::next(bool nextDown) {
4329 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4335 APFloat::opStatus
4344 APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
4348 APFloat Tmp(semPPCDoubleDoubleLegacy);
4354 APFloat::opStatus
4359 APFloat Tmp(semPPCDoubleDoubleLegacy);
4365 APFloat::opStatus
4370 APFloat Tmp(semPPCDoubleDoubleLegacy);
4422 bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
4424 APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4427 APFloat Inv(semPPCDoubleDoubleLegacy);
4433 DoubleAPFloat scalbn(DoubleAPFloat Arg, int Exp, APFloat::roundingMode RM) {
4440 APFloat::roundingMode RM) {
4442 APFloat First = frexp(Arg.Floats[0], Exp, RM);
4443 APFloat Second = Arg.Floats[1];
4444 if (Arg.getCategory() == APFloat::fcNormal)
4466 APFloat::opStatus APFloat::convertFromString(StringRef Str, roundingMode RM) {
4470 hash_code hash_value(const APFloat &Arg) {
4471 if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics()))
4473 if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics()))
4483 APFloat::opStatus APFloat::convert(const fltSemantics &ToSemantics,
4508 APFloat APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE) {
4548 APFloat::opStatus APFloat::convertToInteger(APSInt &result,
lib/Support/ScaledNumber.cpp 185 APFloat Float(APFloat::x87DoubleExtended(), APInt(80, RawBits));
185 APFloat Float(APFloat::x87DoubleExtended(), APInt(80, RawBits));
lib/Support/StringRef.cpp 584 APFloat F(0.0);
585 APFloat::opStatus Status =
586 F.convertFromString(*this, APFloat::rmNearestTiesToEven);
587 if (Status != APFloat::opOK) {
588 if (!AllowInexact || !(Status & APFloat::opInexact))
lib/Target/AArch64/AArch64FastISel.cpp 406 const APFloat Val = CFP->getValueAPF();
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp 2598 APFloat FVal(0.0);
2625 FVal.convertToInteger(IntVal, APFloat::rmTowardZero, &IsExact);
lib/Target/AArch64/AArch64ISelLowering.cpp 5708 bool AArch64TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/AArch64/AArch64ISelLowering.h 313 bool isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/AArch64/AArch64InstructionSelector.cpp 3347 const APFloat &ImmValAPF = ImmOp.getFPImm()->getValueAPF();
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp 519 APFloat getFPImm() const {
521 return APFloat(APFloat::IEEEdouble(), APInt(64, FPImm.Val, true));
1223 APFloat RealVal(APFloat::IEEEdouble());
1223 APFloat RealVal(APFloat::IEEEdouble());
1224 if (RealVal.convertFromString(Desc->Repr, APFloat::rmTowardZero) !=
1225 APFloat::opOK)
1901 CreateFPImm(APFloat Val, bool IsExact, SMLoc S, MCContext &Ctx) {
2574 APFloat F((double)AArch64_AM::getFPImmFloat(Tok.getIntVal()));
2579 APFloat RealVal(APFloat::IEEEdouble());
2579 APFloat RealVal(APFloat::IEEEdouble());
2581 RealVal.convertFromString(Tok.getString(), APFloat::rmTowardZero);
2592 RealVal, Status == APFloat::opOK, S, getContext()));
3640 APFloat RealVal(APFloat::IEEEdouble(), Tok.getString());
3640 APFloat RealVal(APFloat::IEEEdouble(), Tok.getString());
lib/Target/AArch64/MCTargetDesc/AArch64AddressingModes.h 386 static inline int getFP16Imm(const APFloat &FPImm) {
414 static inline int getFP32Imm(const APFloat &FPImm) {
442 static inline int getFP64Imm(const APFloat &FPImm) {
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 625 bool AMDGPUTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
2128 APFloat C1Val(APFloat::IEEEdouble(), "0x1.0p+52");
2128 APFloat C1Val(APFloat::IEEEdouble(), "0x1.0p+52");
2139 APFloat C2Val(APFloat::IEEEdouble(), "0x1.fffffffffffffp+51");
2139 APFloat C2Val(APFloat::IEEEdouble(), "0x1.fffffffffffffp+51");
3588 static bool isInv2Pi(const APFloat &APF) {
3589 static const APFloat KF16(APFloat::IEEEhalf(), APInt(16, 0x3118));
3589 static const APFloat KF16(APFloat::IEEEhalf(), APInt(16, 0x3118));
3590 static const APFloat KF32(APFloat::IEEEsingle(), APInt(32, 0x3e22f983));
3590 static const APFloat KF32(APFloat::IEEEsingle(), APInt(32, 0x3e22f983));
3591 static const APFloat KF64(APFloat::IEEEdouble(), APInt(64, 0x3fc45f306dc9c882));
3591 static const APFloat KF64(APFloat::IEEEdouble(), APInt(64, 0x3fc45f306dc9c882));
3865 const APFloat &Val = CFP->getValueAPF();
3866 APFloat One(Val.getSemantics(), "1.0");
lib/Target/AMDGPU/AMDGPUISelLowering.h 180 bool isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp 1325 APFloat C1Val(APFloat::IEEEdouble(), "0x1.0p+52");
1325 APFloat C1Val(APFloat::IEEEdouble(), "0x1.0p+52");
1326 APFloat C2Val(APFloat::IEEEdouble(), "0x1.fffffffffffffp+51");
1326 APFloat C2Val(APFloat::IEEEdouble(), "0x1.fffffffffffffp+51");
1982 const APFloat C0Val(1.0f);
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 416 APFloat Val(fpCons->getValueAPF());
418 Val.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
418 Val.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp 1454 return &APFloat::IEEEsingle();
1456 return &APFloat::IEEEdouble();
1458 return &APFloat::IEEEhalf();
1476 return &APFloat::IEEEsingle();
1481 return &APFloat::IEEEdouble();
1494 return &APFloat::IEEEhalf();
1504 static bool canLosslesslyConvertToFPType(APFloat &FPLiteral, MVT VT) {
1508 APFloat::opStatus Status = FPLiteral.convert(*getFltSemantics(VT),
1509 APFloat::rmNearestTiesToEven,
1512 if (Status != APFloat::opOK &&
1514 ((Status & APFloat::opOverflow) != 0 ||
1515 (Status & APFloat::opUnderflow) != 0)) {
1552 APFloat FPLiteral(APFloat::IEEEdouble(), APInt(64, Imm.Val));
1552 APFloat FPLiteral(APFloat::IEEEdouble(), APInt(64, Imm.Val));
1632 APFloat FPLiteral(APFloat::IEEEdouble(), APInt(64, Imm.Val));
1632 APFloat FPLiteral(APFloat::IEEEdouble(), APInt(64, Imm.Val));
1763 APFloat FPLiteral(APFloat::IEEEdouble(), Literal);
1763 APFloat FPLiteral(APFloat::IEEEdouble(), Literal);
1766 APFloat::rmNearestTiesToEven, &lost);
1857 APFloat FPLiteral(APFloat::IEEEdouble(), Literal);
1857 APFloat FPLiteral(APFloat::IEEEdouble(), Literal);
1859 APFloat::rmNearestTiesToEven, &Lost);
2363 APFloat RealVal(APFloat::IEEEdouble());
2363 APFloat RealVal(APFloat::IEEEdouble());
2364 auto roundMode = APFloat::rmNearestTiesToEven;
2365 if (RealVal.convertFromString(Num, roundMode) == APFloat::opInvalidOp) {
lib/Target/AMDGPU/SIISelLowering.cpp 5767 APFloat Max = APFloat::getLargest(Type->getFltSemantics());
5767 APFloat Max = APFloat::getLargest(Type->getFltSemantics());
5768 APFloat Min = APFloat::getLargest(Type->getFltSemantics(), true);
5768 APFloat Min = APFloat::getLargest(Type->getFltSemantics(), true);
7637 const APFloat K0Val(BitsToFloat(0x6f800000));
7640 const APFloat K1Val(BitsToFloat(0x2f800000));
8720 auto F = CFP->getValueAPF();
8873 SelectionDAG &DAG, const SDLoc &SL, EVT VT, const APFloat &C) const {
8879 APFloat CanonicalQNaN = APFloat::getQNaN(C.getSemantics());
8879 APFloat CanonicalQNaN = APFloat::getQNaN(C.getSemantics());
8911 APFloat QNaN = APFloat::getQNaN(SelectionDAG::EVTToAPFloatSemantics(VT));
8911 APFloat QNaN = APFloat::getQNaN(SelectionDAG::EVTToAPFloatSemantics(VT));
9074 APFloat::cmpResult Cmp = K0->getValueAPF().compare(K1->getValueAPF());
9075 if (Cmp == APFloat::cmpGreaterThan)
9846 const APFloat &APF = CRHS->getValueAPF();
9915 const APFloat &F = CSrc->getValueAPF();
9916 APFloat Zero = APFloat::getZero(F.getSemantics());
9916 APFloat Zero = APFloat::getZero(F.getSemantics());
9917 APFloat::cmpResult Cmp0 = F.compare(Zero);
9918 if (Cmp0 == APFloat::cmpLessThan ||
9919 (Cmp0 == APFloat::cmpUnordered &&
9924 APFloat One(F.getSemantics(), "1.0");
9925 APFloat::cmpResult Cmp1 = F.compare(One);
9926 if (Cmp1 == APFloat::cmpGreaterThan)
lib/Target/AMDGPU/SIISelLowering.h 157 const APFloat &C) const;
lib/Target/ARM/ARMFastISel.cpp 422 const APFloat Val = CFP->getValueAPF();
lib/Target/ARM/ARMISelLowering.cpp 6514 const APFloat &FPVal = CFP->getValueAPF();
16224 bool ARMTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/ARM/ARMISelLowering.h 505 bool isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/ARM/ARMInstructionSelector.cpp 817 APFloat FPImmValue = OldInst.getOperand(1).getFPImm()->getValueAPF();
829 APFloat FPImmValue = OldInst.getOperand(1).getFPImm()->getValueAPF();
lib/Target/ARM/ARMMCInstLower.cpp 110 APFloat Val = MO.getFPImm()->getValueAPF();
112 Val.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &ignored);
112 Val.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &ignored);
lib/Target/ARM/AsmParser/ARMAsmParser.cpp 5949 APFloat RealVal(APFloat::IEEEsingle(), Tok.getString());
5949 APFloat RealVal(APFloat::IEEEsingle(), Tok.getString());
lib/Target/ARM/MCTargetDesc/ARMAddressingModes.h 672 inline int getFP16Imm(const APFloat &FPImm) {
700 inline int getFP32Imm(const APFloat &FPImm) {
728 inline int getFP64Imm(const APFloat &FPImm) {
lib/Target/Hexagon/HexagonConstExtenders.cpp 727 const APFloat &ThisF = V.CFP->getValueAPF();
728 const APFloat &OtherF = ER.V.CFP->getValueAPF();
lib/Target/Hexagon/HexagonConstPropagation.cpp 351 bool constToFloat(const Constant *C, APFloat &Val) const;
441 const APFloat &Val = CF->getValueAPF();
lib/Target/Hexagon/HexagonISelLowering.cpp 3053 bool HexagonTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/Hexagon/HexagonISelLowering.h 294 bool isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/Hexagon/HexagonMCInstLower.cpp 130 APFloat Val = MO.getFPImm()->getValueAPF();
lib/Target/Mips/AsmParser/MipsAsmParser.cpp 3263 APFloat RealVal(APFloat::IEEEdouble(), ImmOp64);
3263 APFloat RealVal(APFloat::IEEEdouble(), ImmOp64);
lib/Target/Mips/MipsISelLowering.cpp 4151 bool MipsTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/Mips/MipsISelLowering.h 681 bool isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/Mips/MipsInstructionSelector.cpp 478 const APFloat &FPimm = I.getOperand(1).getFPImm()->getValueAPF();
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 261 const APFloat &Val = Cnt->getValueAPF();
1691 APFloat APF = APFloat(Fp->getValueAPF()); // make a copy
1699 APF.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &ignored);
1699 APF.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &ignored);
1703 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &ignored);
1703 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &ignored);
lib/Target/NVPTX/NVPTXMCExpr.cpp 19 NVPTXFloatMCExpr::create(VariantKind Kind, const APFloat &Flt, MCContext &Ctx) {
26 APFloat APF = getAPFloat();
35 APF.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
35 APF.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
40 APF.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &Ignored);
40 APF.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &Ignored);
45 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &Ignored);
45 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &Ignored);
lib/Target/NVPTX/NVPTXMCExpr.h 31 const APFloat Flt;
33 explicit NVPTXFloatMCExpr(VariantKind Kind, APFloat Flt)
40 static const NVPTXFloatMCExpr *create(VariantKind Kind, const APFloat &Flt,
43 static const NVPTXFloatMCExpr *createConstantFPHalf(const APFloat &Flt,
48 static const NVPTXFloatMCExpr *createConstantFPSingle(const APFloat &Flt,
53 static const NVPTXFloatMCExpr *createConstantFPDouble(const APFloat &Flt,
66 APFloat getAPFloat() const { return Flt; }
lib/Target/PowerPC/PPCISelLowering.cpp 7467 APFloat APF = APFloat(APFloat::PPCDoubleDouble(), APInt(128, TwoE31));
7467 APFloat APF = APFloat(APFloat::PPCDoubleDouble(), APInt(128, TwoE31));
15081 bool PPCTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/PowerPC/PPCISelLowering.h 948 bool isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp 1596 APFloat Imm = cast<ConstantFPSDNode>(Node)->getValueAPF();
lib/Target/SystemZ/SystemZISelLowering.cpp 743 SystemZVectorConstantInfo::SystemZVectorConstantInfo(APFloat FPImm) {
745 isFP128 = (&FPImm.getSemantics() == &APFloat::IEEEquad());
779 bool SystemZTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
lib/Target/SystemZ/SystemZISelLowering.h 408 bool isFPImmLegal(const APFloat &Imm, EVT VT,
673 SystemZVectorConstantInfo(APFloat FPImm);
lib/Target/SystemZ/SystemZTDC.cpp 130 APFloat Smallest = APFloat::getSmallestNormalized(Sem);
130 APFloat Smallest = APFloat::getSmallestNormalized(Sem);
131 APFloat NegSmallest = Smallest;
lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp 184 static std::string toString(const APFloat &FP) {
186 if (FP.isNaN() && !FP.bitwiseIsEqual(APFloat::getQNaN(FP.getSemantics())) &&
188 APFloat::getQNaN(FP.getSemantics(), /*Negative=*/true))) {
201 Buf, /*HexDigits=*/0, /*UpperCase=*/false, APFloat::rmNearestTiesToEven);
lib/Target/X86/X86ISelLowering.cpp 633 APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended());
633 APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended());
633 APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended());
639 APFloat TmpFlt2(+1.0);
640 TmpFlt2.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
640 TmpFlt2.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
669 addLegalFPImmediate(APFloat::getZero(APFloat::IEEEquad())); // xorps
669 addLegalFPImmediate(APFloat::getZero(APFloat::IEEEquad())); // xorps
4850 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
5418 APFloat FV(APFloat::IEEEsingle(), V);
5418 APFloat FV(APFloat::IEEEsingle(), V);
5421 APFloat FV(APFloat::IEEEdouble(), V);
5421 APFloat FV(APFloat::IEEEdouble(), V);
8081 Const = ConstantFP::get(C, APFloat(APFloat::IEEEsingle(), Val));
8084 Const = ConstantFP::get(C, APFloat(APFloat::IEEEdouble(), Val));
8249 APFloat(APFloat::IEEEsingle(), SplatValue))
8251 APFloat(APFloat::IEEEdouble(), SplatValue));
10913 APFloat::getAllOnesValue(EltVT.getSizeInBits(), true), DL, EltVT);
18567 ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble(),
18570 ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble(),
18761 APFloat(APFloat::IEEEsingle(), APInt(32, 0xD3000080)), DL, VecFloatVT);
18962 APFloat Thresh(APFloat::IEEEsingle(), APInt(32, 0x5f000000));
18962 APFloat Thresh(APFloat::IEEEsingle(), APInt(32, 0x5f000000));
18963 LLVM_ATTRIBUTE_UNUSED APFloat::opStatus Status = APFloat::opOK;
18963 LLVM_ATTRIBUTE_UNUSED APFloat::opStatus Status = APFloat::opOK;
18967 Status = Thresh.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
18967 Status = Thresh.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
18970 Status = Thresh.convert(APFloat::x87DoubleExtended(),
18971 APFloat::rmNearestTiesToEven, &LosesInfo);
19851 APFloat APF = Op0CN->getValueAPF();
35579 APFloat F64(APFloat::IEEEdouble(), EltBits[0]);
35579 APFloat F64(APFloat::IEEEdouble(), EltBits[0]);
lib/Target/X86/X86ISelLowering.h 1077 bool isFPImmLegal(const APFloat &Imm, EVT VT,
1270 std::vector<APFloat> LegalFPImmediates;
1274 void addLegalFPImmediate(const APFloat& Imm) {
lib/Target/X86/X86MCInstLower.cpp 1724 static void printConstant(const APFloat &Flt, raw_ostream &CS) {
lib/Transforms/InstCombine/InstCombineAddSub.cpp 69 void set(const APFloat& C);
84 APFloat *getFpValPtr()
87 const APFloat *getFpValPtr() const
90 const APFloat &getFpVal() const {
95 APFloat &getFpVal() {
109 APFloat createAPFloatFromInt(const fltSemantics &Sem, int Val);
122 AlignedCharArrayUnion<APFloat> FpValBuf;
147 void set(const APFloat &Coefficient, Value *V) {
228 void FAddendCoef::set(const APFloat& C) {
229 APFloat *P = getFpValPtr();
234 new(P) APFloat(C);
245 APFloat *P = getFpValPtr();
247 new(P) APFloat(Sem, IntVal);
249 new(P) APFloat(Sem, 0 - IntVal);
255 APFloat FAddendCoef::createAPFloatFromInt(const fltSemantics &Sem, int Val) {
259 APFloat T(Sem, 0 - Val);
273 enum APFloat::roundingMode RndMode = APFloat::rmNearestTiesToEven;
273 enum APFloat::roundingMode RndMode = APFloat::rmNearestTiesToEven;
283 const APFloat &T = That.getFpVal();
289 APFloat &T = getFpVal();
314 APFloat &F0 = getFpVal();
318 APFloat::rmNearestTiesToEven);
320 F0.multiply(That.getFpVal(), APFloat::rmNearestTiesToEven);
1467 const APFloat *C;
1530 APFloat::semanticsPrecision(FScalarTy->getFltSemantics());
lib/Transforms/InstCombine/InstCombineCalls.cpp 1379 static APFloat fmed3AMDGCN(const APFloat &Src0, const APFloat &Src1,
1379 static APFloat fmed3AMDGCN(const APFloat &Src0, const APFloat &Src1,
1379 static APFloat fmed3AMDGCN(const APFloat &Src0, const APFloat &Src1,
1380 const APFloat &Src2) {
1381 APFloat Max3 = maxnum(maxnum(Src0, Src1), Src2);
1383 APFloat::cmpResult Cmp0 = Max3.compare(Src0);
1385 if (Cmp0 == APFloat::cmpEqual)
1388 APFloat::cmpResult Cmp1 = Max3.compare(Src1);
1390 if (Cmp1 == APFloat::cmpEqual)
2192 const APFloat *C1, *C2;
2199 APFloat Res(0.0);
3332 const APFloat &ArgVal = C->getValueAPF();
3333 APFloat Val(ArgVal.getSemantics(), 1.0);
3334 APFloat::opStatus Status = Val.divide(ArgVal,
3335 APFloat::rmNearestTiesToEven);
3338 if (Status == APFloat::opOK)
3357 APFloat Significand = frexp(C->getValueAPF(), Exp,
3358 APFloat::rmNearestTiesToEven);
3366 if (Exp == APFloat::IEK_NaN || Exp == APFloat::IEK_Inf)
3366 if (Exp == APFloat::IEK_NaN || Exp == APFloat::IEK_Inf)
3456 const APFloat &Val = CVal->getValueAPF();
3480 APFloat Val0 = C0->getValueAPF();
3481 APFloat Val1 = C1->getValueAPF();
3482 Val0.convert(HalfSem, APFloat::rmTowardZero, &LosesInfo);
3483 Val1.convert(HalfSem, APFloat::rmTowardZero, &LosesInfo);
3651 APFloat Result = fmed3AMDGCN(C0->getValueAPF(), C1->getValueAPF(),
lib/Transforms/InstCombine/InstCombineCasts.cpp 1451 APFloat F = CFP->getValueAPF();
1452 (void)F.convert(Sem, APFloat::rmNearestTiesToEven, &losesInfo);
1460 if (fitsInFPType(CFP, APFloat::IEEEhalf()))
1463 if (fitsInFPType(CFP, APFloat::IEEEsingle()))
1467 if (fitsInFPType(CFP, APFloat::IEEEdouble()))
lib/Transforms/InstCombine/InstCombineCompares.cpp 5607 const APFloat &RHS = cast<ConstantFP>(RHSC)->getValueAPF();
5622 RHS.convertToInteger(RHSCvt, APFloat::rmNearestTiesToEven, &IsExact);
5628 APFloat RHSRoundInt(RHS);
5629 RHSRoundInt.roundToIntegral(APFloat::rmNearestTiesToEven);
5630 if (RHS.compare(RHSRoundInt) != APFloat::cmpEqual) {
5654 if (Exp == APFloat::IEK_Inf) {
5655 int MaxExponent = ilogb(APFloat::getLargest(RHS.getSemantics()));
5715 APFloat SMax(RHS.getSemantics());
5717 APFloat::rmNearestTiesToEven);
5718 if (SMax.compare(RHS) == APFloat::cmpLessThan) { // smax < 13123.0
5727 APFloat UMax(RHS.getSemantics());
5729 APFloat::rmNearestTiesToEven);
5730 if (UMax.compare(RHS) == APFloat::cmpLessThan) { // umax < 13123.0
5740 APFloat SMin(RHS.getSemantics());
5742 APFloat::rmNearestTiesToEven);
5743 if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // smin > 12312.0
5751 APFloat SMin(RHS.getSemantics());
5753 APFloat::rmNearestTiesToEven);
5754 if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // umin > 12312.0
5875 const APFloat *C;
6087 const APFloat *C;
6092 APFloat TruncC = *C;
6093 TruncC.convert(FPSem, APFloat::rmNearestTiesToEven, &Lossy);
6097 APFloat Fabs = TruncC;
6100 ((Fabs.compare(APFloat::getSmallestNormalized(FPSem)) !=
6101 APFloat::cmpLessThan) || Fabs.isZero())) {
lib/Transforms/Scalar/Float2Int.cpp 313 const APFloat &F = CF->getValueAPF();
326 APFloat NewF = F;
327 auto Res = NewF.roundToIntegral(APFloat::rmNearestTiesToEven);
328 if (Res != APFloat::opOK || NewF.compare(F) != APFloat::cmpEqual) {
328 if (Res != APFloat::opOK || NewF.compare(F) != APFloat::cmpEqual) {
337 APFloat::rmNearestTiesToEven,
411 = APFloat::semanticsPrecision(ConvertedToTy->getFltSemantics()) - 1;
452 APFloat::rmNearestTiesToEven,
lib/Transforms/Scalar/IndVarSimplify.cpp 287 static bool ConvertToSInt(const APFloat &APF, int64_t &IntVal) {
292 APFloat::rmTowardZero, &isExact) != APFloat::opOK ||
292 APFloat::rmTowardZero, &isExact) != APFloat::opOK ||
lib/Transforms/Scalar/Reassociate.cpp 1075 const APFloat &F1 = FC1->getValueAPF();
1076 APFloat F2(FC2->getValueAPF());
1078 if (F1.compare(F2) == APFloat::cmpEqual) {
1571 APFloat F(CF->getValueAPF());
1954 const APFloat *C;
2012 const APFloat *C;
lib/Transforms/Utils/FunctionComparator.cpp 74 int FunctionComparator::cmpAPFloats(const APFloat &L, const APFloat &R) const {
74 int FunctionComparator::cmpAPFloats(const APFloat &L, const APFloat &R) const {
78 if (int Res = cmpNumbers(APFloat::semanticsPrecision(SL),
79 APFloat::semanticsPrecision(SR)))
81 if (int Res = cmpNumbers(APFloat::semanticsMaxExponent(SL),
82 APFloat::semanticsMaxExponent(SR)))
84 if (int Res = cmpNumbers(APFloat::semanticsMinExponent(SL),
85 APFloat::semanticsMinExponent(SR)))
87 if (int Res = cmpNumbers(APFloat::semanticsSizeInBits(SL),
88 APFloat::semanticsSizeInBits(SR)))
296 const APFloat &LAPF = cast<ConstantFP>(L)->getValueAPF();
297 const APFloat &RAPF = cast<ConstantFP>(R)->getValueAPF();
lib/Transforms/Utils/SimplifyLibCalls.cpp 1241 APFloat F = Const->getValueAPF();
1243 (void)F.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
1243 (void)F.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
1502 const APFloat *BaseF;
1518 APFloat BaseR = APFloat(1.0);
1519 BaseR.convert(BaseF->getSemantics(), APFloat::rmTowardZero, &Ignored);
1522 const APFloat *NF = IsReciprocal ? &BaseR : BaseF;
1525 NF->convertToInteger(NI, APFloat::rmTowardZero, &Ignored) ==
1526 APFloat::opOK &&
1597 const APFloat *ExpoF;
1691 const APFloat *ExpoF;
1699 APFloat LimF(ExpoF->getSemantics(), 33.0),
1701 if (ExpoA.compare(LimF) == APFloat::cmpLessThan) {
1706 APFloat Expo2 = ExpoA;
1710 if (Expo2.add(ExpoA, APFloat::rmNearestTiesToEven) != APFloat::opOK)
1710 if (Expo2.add(ExpoA, APFloat::rmNearestTiesToEven) != APFloat::opOK)
1727 ExpoA.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &Ignored);
1727 ExpoA.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &Ignored);
1744 ExpoF->convertToInteger(IntExpo, APFloat::rmTowardZero, &Ignored) ==
1745 APFloat::opOK) {
tools/clang/include/clang/AST/APValue.h 117 typedef llvm::APFloat APFloat;
tools/clang/include/clang/AST/Expr.h 621 bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
1413 llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
1416 void setValue(const ASTContext &C, const llvm::APFloat &Val) {
1561 FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
1568 static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
1572 llvm::APFloat getValue() const {
1575 void setValue(const ASTContext &C, const llvm::APFloat &Val) {
tools/clang/include/clang/AST/OptionalDiagnostic.h 34 template <typename T> OptionalDiagnostic &operator<<(const T &v) {
49 OptionalDiagnostic &operator<<(const llvm::APFloat &F) {
57 unsigned precision = llvm::APFloat::semanticsPrecision(F.getSemantics());
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 1196 explicit PolymorphicMatcherWithParam1(const P1 &Param1)
1209 const P1 Param1;
1507 explicit ValueEqualsMatcher(const ValueT &ExpectedValue)
1515 const ValueT ExpectedValue;
1523 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
1525 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
1532 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
1534 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
1541 return ExpectedValue.compare(Node.getValue()) == llvm::APFloat::cmpEqual;
tools/clang/include/clang/Lex/LiteralSupport.h 110 llvm::APFloat::opStatus GetFloatValue(llvm::APFloat &Result);
110 llvm::APFloat::opStatus GetFloatValue(llvm::APFloat &Result);
tools/clang/include/clang/Serialization/ASTReader.h 2229 llvm::APFloat ReadAPFloat(const RecordData &Record,
2641 llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem) {
tools/clang/include/clang/Serialization/ASTWriter.h 864 void AddAPFloat(const llvm::APFloat &Value);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h 261 (&TI.getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended() ||
262 &TI.getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble())))
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h 171 const llvm::APFloat::fltCategory &RHS) {
176 case llvm::APFloat::fcInfinity:
179 case llvm::APFloat::fcNaN:
182 case llvm::APFloat::fcNormal:
185 case llvm::APFloat::fcZero:
478 llvm::APFloat Zero =
479 llvm::APFloat::getZero(Ctx.getFloatTypeSemantics(Ty));
tools/clang/lib/AST/APValue.cpp 386 static double GetApproxValue(const llvm::APFloat &F) {
387 llvm::APFloat V = F;
389 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
389 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
tools/clang/lib/AST/Expr.cpp 965 FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,
981 FloatingLiteral::Create(const ASTContext &C, const llvm::APFloat &V,
995 llvm::APFloat V = getValue();
997 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
997 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
tools/clang/lib/AST/ExprConstant.cpp 1428 APFloat FloatReal, FloatImag;
1430 ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1430 ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1434 APFloat &getComplexFloatReal() { return FloatReal; }
1435 APFloat &getComplexFloatImag() { return FloatImag; }
1737 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
2336 const T &SrcValue, QualType DestType) {
2343 QualType SrcType, const APFloat &Value,
2351 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
2352 & APFloat::opInvalidOp)
2359 APFloat &Result) {
2360 APFloat Value = Result;
2363 APFloat::rmNearestTiesToEven, &ignored);
2382 QualType DestType, APFloat &Result) {
2385 APFloat::rmNearestTiesToEven);
2587 APFloat &LHS, BinaryOperatorKind Opcode,
2588 const APFloat &RHS) {
2594 LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
2597 LHS.add(RHS, APFloat::rmNearestTiesToEven);
2600 LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
2607 LHS.divide(RHS, APFloat::rmNearestTiesToEven);
3374 bool found(APFloat &Value, QualType SubobjType) {
3428 bool found(APFloat &Value, QualType SubobjType) {
3857 APFloat FValue(0.0);
3868 bool found(APFloat &Value, QualType SubobjType) {
4015 bool found(APFloat &Value, QualType SubobjType) {
4021 APFloat One(Value.getSemantics(), 1);
4023 Value.add(One, APFloat::rmNearestTiesToEven);
4025 Value.subtract(One, APFloat::rmNearestTiesToEven);
4953 bool found(APFloat &Value, QualType SubobjType) { return true; }
5306 bool found(APFloat &Value, QualType SubobjType) {
5928 bool found(APFloat &Value, QualType SubobjType) {
6310 bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
8616 bool found(APFloat &Value, QualType SubobjType) {
9275 APFloat FloatResult(0.0);
9300 if (&Sem == &APFloat::x87DoubleExtended())
9364 llvm::APFloat f(0.0);
9369 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
9387 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
10630 APFloat Val(0.0);
10635 case APFloat::fcNaN: Arg = 0; break;
10636 case APFloat::fcInfinity: Arg = 1; break;
10637 case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
10638 case APFloat::fcZero: Arg = 4; break;
10644 APFloat Val(0.0);
10650 APFloat Val(0.0);
10656 APFloat Val(0.0);
10662 APFloat Val(0.0);
10668 APFloat Val(0.0);
11514 APFloat::cmpResult CR_r =
11516 APFloat::cmpResult CR_i =
11518 bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
11518 bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
11530 APFloat RHS(0.0), LHS(0.0);
11542 case APFloat::cmpEqual:
11544 case APFloat::cmpLessThan:
11546 case APFloat::cmpGreaterThan:
11548 case APFloat::cmpUnordered:
12216 APFloat F(0.0);
12374 APFloat &Result;
12376 FloatExprEvaluator(EvalInfo &info, APFloat &result)
12385 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
12403 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
12412 llvm::APFloat &Result) {
12428 Result = llvm::APFloat::getSNaN(Sem, false, &fill);
12430 Result = llvm::APFloat::getQNaN(Sem, false, &fill);
12438 Result = llvm::APFloat::getQNaN(Sem, false, &fill);
12440 Result = llvm::APFloat::getSNaN(Sem, false, &fill);
12461 Result = llvm::APFloat::getInf(Sem);
12504 APFloat RHS(0.);
12537 Result = llvm::APFloat::getZero(Sem);
12558 APFloat RHS(0.0);
12644 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
12644 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
12661 APFloat &Imag = Result.FloatImag;
12747 APFloat &Real = Result.FloatReal;
12834 APFloat &Real = Result.FloatReal;
12849 APFloat &Real = RHS.FloatReal;
12864 APFloat::rmNearestTiesToEven);
12869 APFloat::rmNearestTiesToEven);
12878 APFloat::rmNearestTiesToEven);
12884 APFloat::rmNearestTiesToEven);
12898 APFloat &A = LHS.getComplexFloatReal();
12899 APFloat &B = LHS.getComplexFloatImag();
12900 APFloat &C = RHS.getComplexFloatReal();
12901 APFloat &D = RHS.getComplexFloatImag();
12902 APFloat &ResR = Result.getComplexFloatReal();
12903 APFloat &ResI = Result.getComplexFloatImag();
12914 APFloat AC = A * C;
12915 APFloat BD = B * D;
12916 APFloat AD = A * D;
12917 APFloat BC = B * C;
12923 A = APFloat::copySign(
12925 B = APFloat::copySign(
12928 C = APFloat::copySign(APFloat(C.getSemantics()), C);
12930 D = APFloat::copySign(APFloat(D.getSemantics()), D);
12934 C = APFloat::copySign(
12936 D = APFloat::copySign(
12939 A = APFloat::copySign(APFloat(A.getSemantics()), A);
12941 B = APFloat::copySign(APFloat(B.getSemantics()), B);
12947 A = APFloat::copySign(APFloat(A.getSemantics()), A);
12949 B = APFloat::copySign(APFloat(B.getSemantics()), B);
12951 C = APFloat::copySign(APFloat(C.getSemantics()), C);
12953 D = APFloat::copySign(APFloat(D.getSemantics()), D);
12957 ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D);
12958 ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C);
12979 APFloat &A = LHS.getComplexFloatReal();
12980 APFloat &B = LHS.getComplexFloatImag();
12981 APFloat &C = RHS.getComplexFloatReal();
12982 APFloat &D = RHS.getComplexFloatImag();
12983 APFloat &ResR = Result.getComplexFloatReal();
12984 APFloat &ResI = Result.getComplexFloatImag();
12991 B = APFloat::getZero(A.getSemantics());
12994 APFloat MaxCD = maxnum(abs(C), abs(D));
12997 C = scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven);
12998 D = scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven);
13000 APFloat Denom = C * C + D * D;
13002 APFloat::rmNearestTiesToEven);
13004 APFloat::rmNearestTiesToEven);
13007 ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A;
13008 ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B;
13011 A = APFloat::copySign(
13013 B = APFloat::copySign(
13015 ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D);
13016 ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D);
13018 C = APFloat::copySign(
13020 D = APFloat::copySign(
13022 ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D);
13023 ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D);
13294 llvm::APFloat F(0.0);
13536 bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
14140 llvm::APFloat::rmTowardZero,
14141 &Ignored) & APFloat::opInvalidOp)
tools/clang/lib/AST/ItaniumMangle.cpp 423 void mangleFloat(const llvm::APFloat &F);
1004 void CXXNameMangler::mangleFloat(const llvm::APFloat &f) {
tools/clang/lib/Basic/TargetInfo.cpp 104 HalfFormat = &llvm::APFloat::IEEEhalf();
105 FloatFormat = &llvm::APFloat::IEEEsingle();
106 DoubleFormat = &llvm::APFloat::IEEEdouble();
107 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
108 Float128Format = &llvm::APFloat::IEEEquad();
273 if (&getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended())
277 if (&getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble() ||
278 &getLongDoubleFormat() == &llvm::APFloat::IEEEquad())
363 DoubleFormat = &llvm::APFloat::IEEEdouble();
377 HalfFormat = &llvm::APFloat::IEEEhalf();
378 FloatFormat = &llvm::APFloat::IEEEsingle();
379 LongDoubleFormat = &llvm::APFloat::IEEEquad();
389 LongDoubleFormat = &llvm::APFloat::IEEEquad();
tools/clang/lib/Basic/Targets/AArch64.cpp 60 LongDoubleFormat = &llvm::APFloat::IEEEquad();
553 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
637 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
tools/clang/lib/Basic/Targets/AVR.h 46 DoubleFormat = &llvm::APFloat::IEEEsingle();
49 LongDoubleFormat = &llvm::APFloat::IEEEsingle();
tools/clang/lib/Basic/Targets/Mips.h 121 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
133 LongDoubleFormat = &llvm::APFloat::IEEEquad();
136 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
tools/clang/lib/Basic/Targets/OSTargets.h 774 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
tools/clang/lib/Basic/Targets/PPC.cpp 60 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
476 if (LongDoubleFormat != &llvm::APFloat::IEEEdouble())
478 ? &llvm::APFloat::IEEEquad()
479 : &llvm::APFloat::PPCDoubleDouble();
tools/clang/lib/Basic/Targets/PPC.h 80 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble();
321 return LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble()
355 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
392 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
tools/clang/lib/Basic/Targets/RISCV.h 40 LongDoubleFormat = &llvm::APFloat::IEEEquad();
tools/clang/lib/Basic/Targets/Sparc.h 212 LongDoubleFormat = &llvm::APFloat::IEEEquad();
tools/clang/lib/Basic/Targets/SystemZ.h 45 LongDoubleFormat = &llvm::APFloat::IEEEquad();
tools/clang/lib/Basic/Targets/TCE.h 67 FloatFormat = &llvm::APFloat::IEEEsingle();
68 DoubleFormat = &llvm::APFloat::IEEEsingle();
69 LongDoubleFormat = &llvm::APFloat::IEEEsingle();
tools/clang/lib/Basic/Targets/WebAssembly.h 52 LongDoubleFormat = &llvm::APFloat::IEEEquad();
tools/clang/lib/Basic/Targets/X86.h 132 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
136 return LongDoubleFormat == &llvm::APFloat::IEEEquad() ? "g" : "e";
484 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
557 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
751 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
776 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
847 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
857 LongDoubleFormat = &llvm::APFloat::IEEEquad();
tools/clang/lib/CodeGen/CGBuiltin.cpp 2276 APFloat Smallest = APFloat::getSmallestNormalized(
2276 APFloat Smallest = APFloat::getSmallestNormalized(
2339 APFloat Smallest = APFloat::getSmallestNormalized(
2339 APFloat Smallest = APFloat::getSmallestNormalized(
tools/clang/lib/CodeGen/CGExpr.cpp 1001 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
tools/clang/lib/CodeGen/CGExprConstant.cpp 2039 const llvm::APFloat &Init = Value.getFloat();
2040 if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf() &&
tools/clang/lib/CodeGen/CGExprScalar.cpp 893 APFloat MinSrc(SrcSema, APFloat::uninitialized);
893 APFloat MinSrc(SrcSema, APFloat::uninitialized);
894 if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
895 APFloat::opOverflow)
898 MinSrc = APFloat::getInf(SrcSema, true);
902 MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);
905 APFloat MaxSrc(SrcSema, APFloat::uninitialized);
905 APFloat MaxSrc(SrcSema, APFloat::uninitialized);
906 if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
907 APFloat::opOverflow)
910 MaxSrc = APFloat::getInf(SrcSema, false);
914 MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);
922 MinSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
923 MaxSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
2513 llvm::APFloat F(static_cast<float>(amount));
2524 F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
tools/clang/lib/CodeGen/CodeGenTypes.cpp 292 if (&format == &llvm::APFloat::IEEEhalf()) {
298 if (&format == &llvm::APFloat::IEEEsingle())
300 if (&format == &llvm::APFloat::IEEEdouble())
302 if (&format == &llvm::APFloat::IEEEquad())
304 if (&format == &llvm::APFloat::PPCDoubleDouble())
306 if (&format == &llvm::APFloat::x87DoubleExtended())
tools/clang/lib/CodeGen/PatternInit.cpp 56 unsigned BitWidth = llvm::APFloat::semanticsSizeInBits(
tools/clang/lib/CodeGen/TargetInfo.cpp 957 &llvm::APFloat::x87DoubleExtended())
2584 if (LDF == &llvm::APFloat::IEEEquad()) {
2587 } else if (LDF == &llvm::APFloat::x87DoubleExtended()) {
2590 } else if (LDF == &llvm::APFloat::IEEEdouble()) {
2717 if (LDF == &llvm::APFloat::IEEEquad())
2719 else if (LDF == &llvm::APFloat::x87DoubleExtended())
2721 else if (LDF == &llvm::APFloat::IEEEdouble())
4012 if (LDF == &llvm::APFloat::x87DoubleExtended())
tools/clang/lib/Frontend/InitPreprocessor.cpp 98 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEhalf())
100 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle())
102 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble())
104 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended())
106 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble())
tools/clang/lib/Lex/LiteralSupport.cpp 1039 llvm::APFloat::opStatus
1040 NumericLiteralParser::GetFloatValue(llvm::APFloat &Result) {
1054 return Result.convertFromString(Str, APFloat::rmNearestTiesToEven);
tools/clang/lib/Sema/SemaChecking.cpp10441 static bool IsSameFloatAfterCast(const llvm::APFloat &value,
10444 llvm::APFloat truncated = value;
10447 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
10448 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
11109 llvm::APFloat Value(0.0);
11128 llvm::APFloat::opStatus Result = Value.convertToInteger(
11129 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
11137 unsigned precision = llvm::APFloat::semanticsPrecision(Value.getSemantics());
11148 if (Result == llvm::APFloat::opOK && isExact) {
11156 if (!IsBool && Result == llvm::APFloat::opInvalidOp)
11803 llvm::APFloat TargetFloatValue(
11805 llvm::APFloat::opStatus ConversionStatus =
11808 llvm::APFloat::rmNearestTiesToEven);
11810 if (ConversionStatus != llvm::APFloat::opOK) {
tools/clang/lib/Sema/SemaExpr.cpp 1133 &llvm::APFloat::PPCDoubleDouble());
3336 APFloat Val(Format);
3338 APFloat::opStatus result = Literal.GetFloatValue(Val);
3342 if ((result & APFloat::opOverflow) ||
3343 ((result & APFloat::opUnderflow) && Val.isZero())) {
3346 if (result & APFloat::opOverflow) {
3348 APFloat::getLargest(Format).toString(buffer);
3351 APFloat::getSmallest(Format).toString(buffer);
3359 bool isExact = (result == APFloat::opOK);
8898 llvm::APFloat Float(S.Context.getFloatTypeSemantics(FloatTy));
8900 llvm::APFloat::rmTowardZero);
8904 Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
8912 unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
8965 llvm::APFloat Result(0.0);
8976 llvm::APFloat::rmNearestTiesToEven, &Truncated);
tools/clang/lib/Sema/SemaOpenMP.cpp13431 llvm::APFloat InitValue =
13432 llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type),
13476 llvm::APFloat InitValue = llvm::APFloat::getLargest(
13476 llvm::APFloat InitValue = llvm::APFloat::getLargest(
tools/clang/lib/Sema/SemaOverload.cpp 354 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
356 llvm::APFloat::rmNearestTiesToEven);
361 llvm::APFloat::rmTowardZero, &ignored);
392 llvm::APFloat FloatVal = ConstantValue.getFloat();
395 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
397 llvm::APFloat::rmNearestTiesToEven, &ignored);
400 if (ConvertStatus & llvm::APFloat::opOverflow) {
1827 &llvm::APFloat::PPCDoubleDouble()))
tools/clang/lib/Serialization/ASTReader.cpp 9626 llvm::APFloat First = ReadAPFloat(Record, FloatSema1, Idx);
9660 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
tools/clang/lib/Serialization/ASTWriter.cpp 5448 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) {
tools/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp 150 RepresentsUntilExp = llvm::APFloat::semanticsPrecision(Sema);
tools/clang/tools/extra/clang-tidy/bugprone/IncorrectRoundingsCheck.cpp 24 const auto &literal = Node.getValue();
25 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
27 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp 92 const Expr &E, llvm::APFloat &Value) {
287 llvm::APFloat FloatConstant(0.0);
299 Result, llvm::APFloat::rmTowardZero, &IsExact) &
300 llvm::APFloat::opInvalidOp;
337 llvm::APFloat Tmp = Constant.getFloat();
tools/clang/tools/extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp 122 llvm::APFloat Value = cast<FloatingLiteral>(E)->getValue();
tools/clang/tools/extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp 162 llvm::APFloat FloatLitAbsValue = FloatLit->getValue();
tools/clang/tools/extra/clang-tidy/readability/MagicNumbersCheck.cpp 78 llvm::APFloat FloatValue(llvm::APFloat::IEEEsingle());
78 llvm::APFloat FloatValue(llvm::APFloat::IEEEsingle());
82 llvm::APFloat DoubleValue(llvm::APFloat::IEEEdouble());
82 llvm::APFloat DoubleValue(llvm::APFloat::IEEEdouble());
136 const llvm::APFloat FloatValue = Literal->getValue();
140 if (&FloatValue.getSemantics() == &llvm::APFloat::IEEEsingle()) {
146 if (&FloatValue.getSemantics() == &llvm::APFloat::IEEEdouble()) {
tools/clang/tools/extra/clang-tidy/readability/MagicNumbersCheck.h 81 constexpr static llvm::APFloat::roundingMode DefaultRoundingMode =
82 llvm::APFloat::rmNearestTiesToEven;
tools/clang/tools/libclang/CIndex.cpp 3834 llvm::APFloat apFloat = ER.Val.getFloat();
3835 apFloat.convert(llvm::APFloat::IEEEdouble(),
3836 llvm::APFloat::rmNearestTiesToEven, &ignored);
tools/lldb/include/lldb/Utility/Scalar.h 91 llvm::APFloat(llvm::APFloat::IEEEquad(),
96 llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
285 llvm::APFloat m_float;
tools/lldb/source/Core/DumpDataExtractor.cpp 577 (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
581 llvm::APFloat apfloat(semantics, apint.getValue());
655 llvm::APFloat ap_float(DE.GetFloat(&offset));
657 llvm::APFloat::rmNearestTiesToEven);
662 llvm::APFloat ap_float(DE.GetDouble(&offset));
664 llvm::APFloat::rmNearestTiesToEven);
tools/lldb/source/Utility/Scalar.cpp 368 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(),
372 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
521 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
523 llvm::APFloat::rmNearestTiesToEven);
528 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
530 llvm::APFloat::rmNearestTiesToEven);
535 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
536 : llvm::APFloat::x87DoubleExtended());
538 llvm::APFloat::rmNearestTiesToEven);
591 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
593 llvm::APFloat::rmNearestTiesToEven);
598 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
600 llvm::APFloat::rmNearestTiesToEven);
605 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
606 : llvm::APFloat::x87DoubleExtended());
608 llvm::APFloat::rmNearestTiesToEven);
657 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
659 llvm::APFloat::rmNearestTiesToEven);
664 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
666 llvm::APFloat::rmNearestTiesToEven);
671 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
672 : llvm::APFloat::x87DoubleExtended());
674 llvm::APFloat::rmNearestTiesToEven);
719 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
721 llvm::APFloat::rmNearestTiesToEven);
726 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
728 llvm::APFloat::rmNearestTiesToEven);
733 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
734 : llvm::APFloat::x87DoubleExtended());
736 llvm::APFloat::rmNearestTiesToEven);
777 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
779 llvm::APFloat::rmNearestTiesToEven);
784 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
786 llvm::APFloat::rmNearestTiesToEven);
791 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
792 : llvm::APFloat::x87DoubleExtended());
794 llvm::APFloat::rmNearestTiesToEven);
831 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
833 llvm::APFloat::rmNearestTiesToEven);
838 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
840 llvm::APFloat::rmNearestTiesToEven);
845 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
846 : llvm::APFloat::x87DoubleExtended());
848 llvm::APFloat::rmNearestTiesToEven);
885 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
887 llvm::APFloat::rmNearestTiesToEven);
892 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
894 llvm::APFloat::rmNearestTiesToEven);
899 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
900 : llvm::APFloat::x87DoubleExtended());
902 llvm::APFloat::rmNearestTiesToEven);
935 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
937 llvm::APFloat::rmNearestTiesToEven);
942 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
944 llvm::APFloat::rmNearestTiesToEven);
949 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
950 : llvm::APFloat::x87DoubleExtended());
952 llvm::APFloat::rmNearestTiesToEven);
985 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
987 llvm::APFloat::rmNearestTiesToEven);
992 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
994 llvm::APFloat::rmNearestTiesToEven);
999 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
1000 : llvm::APFloat::x87DoubleExtended());
1002 llvm::APFloat::rmNearestTiesToEven);
1032 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
1034 llvm::APFloat::rmNearestTiesToEven);
1039 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
1041 llvm::APFloat::rmNearestTiesToEven);
1046 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
1047 : llvm::APFloat::x87DoubleExtended());
1049 llvm::APFloat::rmNearestTiesToEven);
1086 m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
1087 : llvm::APFloat::x87DoubleExtended(),
1088 llvm::APFloat::rmNearestTiesToEven, &ignore);
1117 m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
1118 : llvm::APFloat::x87DoubleExtended(),
1119 llvm::APFloat::rmNearestTiesToEven, &ignore);
2515 llvm::APFloat::x87DoubleExtended(),
2774 llvm::APFloat::cmpResult result;
2795 if (result == llvm::APFloat::cmpEqual)
2812 llvm::APFloat::cmpResult result;
2834 if (result == llvm::APFloat::cmpLessThan)
tools/llvm-exegesis/lib/RegisterValue.cpp 16 static APFloat getFloatValue(const fltSemantics &FltSemantics,
20 return APFloat::getZero(FltSemantics);
22 return APFloat::getZero(FltSemantics, true);
28 return APFloat::getInf(FltSemantics);
30 return APFloat::getQNaN(FltSemantics);
32 return APFloat::getSmallestNormalized(FltSemantics);
34 return APFloat::getLargest(FltSemantics);
36 return APFloat::getSmallest(FltSemantics);
38 auto Output = getFloatValue(FltSemantics, PredefinedValues::ONE);
tools/llvm-pdbutil/PrettyClassDefinitionDumper.cpp 97 APFloat Pct(100.0 * (double)Layout.deepPaddingSize() /
105 APFloat Pct2(100.0 * (double)Layout.immediatePadding() /
tools/llvm-stress/llvm-stress.cpp 440 APFloat RandomFloat(Ty->getFltSemantics(), RandomInt);
unittests/ADT/APFloatTest.cpp 24 llvm::APFloat F(0.0);
25 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
32 llvm::APFloat F(d);
56 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
56 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
56 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
57 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
57 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
57 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
75 test = APFloat::getInf(APFloat::IEEEquad(), false);
75 test = APFloat::getInf(APFloat::IEEEquad(), false);
76 expected = APFloat::getInf(APFloat::IEEEquad(), false);
76 expected = APFloat::getInf(APFloat::IEEEquad(), false);
83 test = APFloat::getInf(APFloat::IEEEquad(), false);
83 test = APFloat::getInf(APFloat::IEEEquad(), false);
84 expected = APFloat::getLargest(APFloat::IEEEquad(), false);
84 expected = APFloat::getLargest(APFloat::IEEEquad(), false);
90 test = APFloat::getInf(APFloat::IEEEquad(), true);
90 test = APFloat::getInf(APFloat::IEEEquad(), true);
91 expected = APFloat::getLargest(APFloat::IEEEquad(), true);
91 expected = APFloat::getLargest(APFloat::IEEEquad(), true);
97 test = APFloat::getInf(APFloat::IEEEquad(), true);
97 test = APFloat::getInf(APFloat::IEEEquad(), true);
98 expected = APFloat::getInf(APFloat::IEEEquad(), true);
98 expected = APFloat::getInf(APFloat::IEEEquad(), true);
104 test = APFloat::getLargest(APFloat::IEEEquad(), false);
104 test = APFloat::getLargest(APFloat::IEEEquad(), false);
105 expected = APFloat::getInf(APFloat::IEEEquad(), false);
105 expected = APFloat::getInf(APFloat::IEEEquad(), false);
113 test = APFloat::getLargest(APFloat::IEEEquad(), false);
113 test = APFloat::getLargest(APFloat::IEEEquad(), false);
114 expected = APFloat(APFloat::IEEEquad(),
121 test = APFloat::getLargest(APFloat::IEEEquad(), true);
121 test = APFloat::getLargest(APFloat::IEEEquad(), true);
122 expected = APFloat(APFloat::IEEEquad(),
128 test = APFloat::getLargest(APFloat::IEEEquad(), true);
128 test = APFloat::getLargest(APFloat::IEEEquad(), true);
129 expected = APFloat::getInf(APFloat::IEEEquad(), true);
129 expected = APFloat::getInf(APFloat::IEEEquad(), true);
135 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
136 expected = APFloat(APFloat::IEEEquad(),
142 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
143 expected = APFloat::getZero(APFloat::IEEEquad(), false);
143 expected = APFloat::getZero(APFloat::IEEEquad(), false);
149 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
150 expected = APFloat::getZero(APFloat::IEEEquad(), true);
150 expected = APFloat::getZero(APFloat::IEEEquad(), true);
156 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
157 expected = APFloat(APFloat::IEEEquad(),
163 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
163 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
164 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
164 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
169 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
169 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
170 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
170 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
175 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
175 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
176 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
176 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
181 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
181 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
182 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
182 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
187 test = APFloat::getZero(APFloat::IEEEquad(), false);
187 test = APFloat::getZero(APFloat::IEEEquad(), false);
188 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
188 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
193 test = APFloat::getZero(APFloat::IEEEquad(), false);
193 test = APFloat::getZero(APFloat::IEEEquad(), false);
194 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
194 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
199 test = APFloat::getZero(APFloat::IEEEquad(), true);
199 test = APFloat::getZero(APFloat::IEEEquad(), true);
200 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
200 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
205 test = APFloat::getZero(APFloat::IEEEquad(), true);
205 test = APFloat::getZero(APFloat::IEEEquad(), true);
206 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
206 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
219 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
220 expected = APFloat(APFloat::IEEEquad(),
227 test = APFloat(APFloat::IEEEquad(),
229 expected = APFloat(APFloat::IEEEquad(),
236 test = APFloat(APFloat::IEEEquad(),
238 expected = APFloat(APFloat::IEEEquad(),
245 test = APFloat(APFloat::IEEEquad(),
247 expected = APFloat(APFloat::IEEEquad(),
260 test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
261 expected = APFloat(APFloat::IEEEquad(),
267 test = APFloat(APFloat::IEEEquad(), "0x1p+1");
268 expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
273 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
274 expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
279 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
280 expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
296 test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
297 expected = APFloat(APFloat::IEEEquad(),
305 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
306 expected = APFloat(APFloat::IEEEquad(),
314 test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
315 expected = APFloat(APFloat::IEEEquad(),
323 test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382");
324 expected = APFloat(APFloat::IEEEquad(),
341 test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
342 expected = APFloat(APFloat::IEEEquad(),
349 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
350 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
355 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
356 expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
361 test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
362 expected = APFloat(APFloat::IEEEquad(),
379 test = APFloat(APFloat::IEEEquad(),
381 expected = APFloat(APFloat::IEEEquad(),
389 test = APFloat(APFloat::IEEEquad(),
391 expected = APFloat(APFloat::IEEEquad(),
399 test = APFloat(APFloat::IEEEquad(),
401 expected = APFloat(APFloat::IEEEquad(),
409 test = APFloat(APFloat::IEEEquad(),
411 expected = APFloat(APFloat::IEEEquad(),
419 test = APFloat(APFloat::IEEEquad(),
421 expected = APFloat(APFloat::IEEEquad(),
429 test = APFloat(APFloat::IEEEquad(),
431 expected = APFloat(APFloat::IEEEquad(),
439 test = APFloat(APFloat::IEEEquad(),
441 expected = APFloat(APFloat::IEEEquad(),
449 test = APFloat(APFloat::IEEEquad(),
451 expected = APFloat(APFloat::IEEEquad(),
460 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
460 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
463 APFloat f1(14.5f);
464 APFloat f2(-14.5f);
465 APFloat f3(225.0f);
466 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
471 APFloat Val2(2.0f);
472 APFloat f1((float)1.17549435e-38F);
473 APFloat f2((float)1.17549435e-38F);
476 APFloat f3(12.0f);
477 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
484 APFloat f1(1.0);
485 APFloat f2(-1.0);
486 APFloat f3(1.0);
487 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
495 APFloat f1(1.0);
496 APFloat f2(-1.0);
497 APFloat f3(1.0);
498 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
505 APFloat f1(0.0);
506 APFloat f2(-0.0);
507 APFloat f3(-0.0);
508 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
514 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
514 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
515 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
515 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
516 APFloat f3(0.0);
517 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
523 APFloat M1(APFloat::x87DoubleExtended(), 1.0);
523 APFloat M1(APFloat::x87DoubleExtended(), 1.0);
524 APFloat M2(APFloat::x87DoubleExtended(), 1.0);
524 APFloat M2(APFloat::x87DoubleExtended(), 1.0);
525 APFloat A(APFloat::x87DoubleExtended(), 3.0);
525 APFloat A(APFloat::x87DoubleExtended(), 3.0);
528 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
529 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
529 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
536 APFloat f1(1.0);
537 APFloat f2(2.0);
538 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
538 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
538 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
547 APFloat f1(1.0);
548 APFloat f2(2.0);
549 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
549 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
549 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
558 APFloat f1(1.0);
559 APFloat f2(2.0);
560 APFloat zp(0.0);
561 APFloat zn(-0.0);
562 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
562 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
562 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
573 APFloat f1(1.0);
574 APFloat f2(2.0);
575 APFloat zp(0.0);
576 APFloat zn(-0.0);
577 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
577 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
577 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
588 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
588 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
596 APFloat Val2(APFloat::IEEEsingle(), 2.0e0);
596 APFloat Val2(APFloat::IEEEsingle(), 2.0e0);
597 APFloat T(APFloat::IEEEsingle(), MinNormalStr);
597 APFloat T(APFloat::IEEEsingle(), MinNormalStr);
608 APFloat Val2(APFloat::IEEEdouble(), 2.0e0);
608 APFloat Val2(APFloat::IEEEdouble(), 2.0e0);
609 APFloat T(APFloat::IEEEdouble(), MinNormalStr);
609 APFloat T(APFloat::IEEEdouble(), MinNormalStr);
620 APFloat Val2(APFloat::x87DoubleExtended(), 2.0e0);
620 APFloat Val2(APFloat::x87DoubleExtended(), 2.0e0);
621 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
621 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
632 APFloat Val2(APFloat::IEEEquad(), 2.0e0);
632 APFloat Val2(APFloat::IEEEquad(), 2.0e0);
633 APFloat T(APFloat::IEEEquad(), MinNormalStr);
633 APFloat T(APFloat::IEEEquad(), MinNormalStr);
652 APFloat Val(APFloat::IEEEdouble());
652 APFloat Val(APFloat::IEEEdouble());
654 llvm::APFloat::rmNearestTiesToEven);
657 llvm::APFloat::rmNearestTiesToEven);
660 llvm::APFloat::rmNearestTiesToEven);
663 llvm::APFloat::rmNearestTiesToEven);
666 llvm::APFloat::rmNearestTiesToEven);
669 llvm::APFloat::rmNearestTiesToEven);
1045 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
1045 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
1103 return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt();
1105 return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt();
1117 { 0x7fc00000ULL, APFloat::IEEEsingle(), false, false, 0x00000000ULL },
1118 { 0xffc00000ULL, APFloat::IEEEsingle(), false, true, 0x00000000ULL },
1119 { 0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false, 0x0000ae72ULL },
1120 { 0x7fffae72ULL, APFloat::IEEEsingle(), false, false, 0xffffae72ULL },
1121 { 0x7fdaae72ULL, APFloat::IEEEsingle(), false, false, 0x00daae72ULL },
1122 { 0x7fa00000ULL, APFloat::IEEEsingle(), true, false, 0x00000000ULL },
1123 { 0xffa00000ULL, APFloat::IEEEsingle(), true, true, 0x00000000ULL },
1124 { 0x7f80ae72ULL, APFloat::IEEEsingle(), true, false, 0x0000ae72ULL },
1125 { 0x7fbfae72ULL, APFloat::IEEEsingle(), true, false, 0xffffae72ULL },
1126 { 0x7f9aae72ULL, APFloat::IEEEsingle(), true, false, 0x001aae72ULL },
1127 { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL },
1128 { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false, true, 0x0000000000000000ULL },
1129 { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL },
1130 { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL },
1131 { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL },
1132 { 0x7ff4000000000000ULL, APFloat::IEEEdouble(), true, false, 0x0000000000000000ULL },
1133 { 0xfff4000000000000ULL, APFloat::IEEEdouble(), true, true, 0x0000000000000000ULL },
1134 { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(), true, false, 0x000000000000ae72ULL },
1135 { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL },
1136 { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(), true, false, 0x0001aaaaaaaaae72ULL },
1318 APFloat inv(0.0f);
1345 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1345 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1345 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1348 P.roundToIntegral(APFloat::rmTowardZero);
1351 P.roundToIntegral(APFloat::rmTowardNegative);
1354 P.roundToIntegral(APFloat::rmTowardPositive);
1357 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1361 P.roundToIntegral(APFloat::rmTowardZero);
1364 P.roundToIntegral(APFloat::rmTowardNegative);
1367 P.roundToIntegral(APFloat::rmTowardPositive);
1370 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1374 P.roundToIntegral(APFloat::rmTowardZero);
1377 P.roundToIntegral(APFloat::rmTowardNegative);
1380 P.roundToIntegral(APFloat::rmTowardPositive);
1383 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1386 P = APFloat::getZero(APFloat::IEEEdouble());
1386 P = APFloat::getZero(APFloat::IEEEdouble());
1387 P.roundToIntegral(APFloat::rmTowardZero);
1389 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1389 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1390 P.roundToIntegral(APFloat::rmTowardZero);
1392 P = APFloat::getNaN(APFloat::IEEEdouble());
1392 P = APFloat::getNaN(APFloat::IEEEdouble());
1393 P.roundToIntegral(APFloat::rmTowardZero);
1395 P = APFloat::getInf(APFloat::IEEEdouble());
1395 P = APFloat::getInf(APFloat::IEEEdouble());
1396 P.roundToIntegral(APFloat::rmTowardZero);
1398 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1398 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1399 P.roundToIntegral(APFloat::rmTowardZero);
1404 APFloat T(-0.0);
1408 T = APFloat::getNaN(APFloat::IEEEdouble());
1408 T = APFloat::getNaN(APFloat::IEEEdouble());
1410 T = APFloat::getInf(APFloat::IEEEdouble());
1410 T = APFloat::getInf(APFloat::IEEEdouble());
1412 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1412 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1414 T = APFloat::getLargest(APFloat::IEEEdouble());
1414 T = APFloat::getLargest(APFloat::IEEEdouble());
1419 APFloat F1(-0.0);
1420 APFloat F2(-0.0);
1421 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1424 APFloat F3(3.14159);
1425 APFloat F4(-0.0);
1426 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1429 APFloat F5(-0.0);
1430 APFloat F6(3.14159);
1431 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1442 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1442 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1442 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1443 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1443 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1449 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1449 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1450 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1456 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1456 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1457 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1463 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1463 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1464 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1472 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1472 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1472 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1473 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1473 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1479 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1479 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1480 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1486 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1486 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1487 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1493 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1493 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1494 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1508 { &APFloat::IEEEhalf(), false, {0, 0}, 1},
1509 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1510 { &APFloat::IEEEsingle(), false, {0, 0}, 1},
1511 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1512 { &APFloat::IEEEdouble(), false, {0, 0}, 1},
1513 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1514 { &APFloat::IEEEquad(), false, {0, 0}, 2},
1515 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1516 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1517 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1518 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1519 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1523 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1523 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1526 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1551 APFloat test(APFloat::IEEEdouble(), "1.0");
1551 APFloat test(APFloat::IEEEdouble(), "1.0");
1552 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1552 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1556 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1557 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1557 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1558 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1558 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1562 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1563 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1563 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1564 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1564 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1568 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1569 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1569 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1573 test = APFloat::getSNaN(APFloat::IEEEsingle());
1573 test = APFloat::getSNaN(APFloat::IEEEsingle());
1574 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1574 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1574 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1575 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1575 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1580 test = APFloat::getQNaN(APFloat::IEEEsingle());
1580 test = APFloat::getQNaN(APFloat::IEEEsingle());
1581 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1581 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1581 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1582 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1582 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1587 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1587 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1588 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1588 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1593 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1593 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1594 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1594 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1601 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1601 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1606 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1611 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1617 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1617 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1618 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1621 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
1622 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1625 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
1626 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1629 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
1630 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1634 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
1635 APFloat::rmNearestTiesToEven);
1638 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
1639 APFloat::rmNearestTiesToEven);
1645 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1645 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1647 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1664 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1664 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1675 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1675 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1685 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1685 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1695 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1695 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1740 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1740 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1740 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1741 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1741 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1741 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1742 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1742 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1742 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1743 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1743 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1743 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1744 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1744 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1744 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1745 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1745 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1745 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1746 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1746 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1747 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1747 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1748 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1748 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1748 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1749 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1749 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1749 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1750 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1750 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1750 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1751 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1751 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1751 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1752 APFloat PSmallestNormalized =
1753 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1753 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1754 APFloat MSmallestNormalized =
1755 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1755 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1757 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1757 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1761 APFloat x;
1762 APFloat y;
1767 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1767 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1768 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1768 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1769 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1769 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1770 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1770 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1771 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1771 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1776 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1776 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1777 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1777 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1778 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1778 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1779 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1779 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1780 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1780 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1781 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1781 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1782 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1782 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1783 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1783 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1784 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1784 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1785 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1785 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1786 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1786 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1787 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1787 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1788 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1788 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1793 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1793 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1794 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1794 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1795 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1795 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1796 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1796 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1797 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1797 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1798 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1798 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1799 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1799 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1800 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1800 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1801 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1801 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1802 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1802 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1803 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1803 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1804 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1804 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1805 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1805 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1810 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1810 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1811 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1811 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1812 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1812 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1813 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1813 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1814 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1814 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1815 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1815 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1816 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1816 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1817 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1817 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1818 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1818 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1819 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1819 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1820 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1820 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1821 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1821 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1822 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1822 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1827 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1827 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1828 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1828 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1829 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1829 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1830 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1830 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1831 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1831 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1832 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1832 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1833 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1833 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1834 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1834 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1835 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1835 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1836 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1836 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1837 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1837 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1838 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1838 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1839 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1839 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1844 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1844 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1845 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1845 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1846 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1846 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1847 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1847 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1848 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1848 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1849 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1849 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1850 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1850 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1851 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1851 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1869 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1869 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1870 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1870 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1871 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1871 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1872 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1872 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1873 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1873 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1878 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1878 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1879 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1879 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1880 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1880 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1881 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1881 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1882 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1882 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1883 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1883 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1884 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1884 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1885 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1885 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1886 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1886 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1887 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1887 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1888 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1888 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1889 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1889 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1890 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1890 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1895 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1895 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1896 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1896 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1897 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1897 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1898 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1898 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1899 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1899 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1900 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1900 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1901 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1901 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1902 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1902 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1903 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1903 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1904 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1904 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1905 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1905 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1906 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1906 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1907 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1907 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1912 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1912 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1913 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1913 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1914 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1915 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1915 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1916 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1916 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1917 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1917 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1918 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1918 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1919 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1919 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1920 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1920 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1921 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1921 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1922 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1922 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1923 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1923 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1924 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1924 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1929 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1929 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1930 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1930 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1931 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1931 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1932 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1933 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1933 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1934 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1934 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1935 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1935 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1936 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1936 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1937 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1937 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1938 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1938 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1939 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1939 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1940 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1940 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1941 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1941 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1946 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1946 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1947 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1947 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1948 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1948 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1949 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1949 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1950 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1950 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1951 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1951 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1952 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1952 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1953 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1953 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1954 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1954 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1955 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1955 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1956 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1956 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1957 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1957 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1958 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1958 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1963 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1963 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1964 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1964 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1965 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1965 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1966 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1966 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1967 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1967 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1968 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1968 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1969 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1969 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1970 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1970 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1971 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1971 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1972 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1972 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1973 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1973 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1974 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1974 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1975 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1975 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1980 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1980 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1981 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1981 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1982 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1982 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1983 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1983 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1984 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1984 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1985 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1985 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1986 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1986 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1987 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1987 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1988 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1988 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1989 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1989 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1990 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1990 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1991 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1991 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1992 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1992 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1997 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1997 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1998 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1998 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1999 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1999 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2000 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2000 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2001 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2001 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2002 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2002 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2003 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2003 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2004 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
2004 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
2008 APFloat x(SpecialCaseTests[i].x);
2009 APFloat y(SpecialCaseTests[i].y);
2010 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
2010 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
2012 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2012 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2028 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2028 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2028 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2029 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2029 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2029 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2030 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2030 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2030 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2031 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2031 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2031 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2032 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2032 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2032 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2033 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2033 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2033 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2034 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2034 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2035 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2035 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2036 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2036 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2036 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2037 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2037 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2037 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2038 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2038 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2038 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2039 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2039 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2039 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2040 APFloat PSmallestNormalized =
2041 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2041 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2042 APFloat MSmallestNormalized =
2043 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2043 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2045 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2045 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2049 APFloat x;
2050 APFloat y;
2055 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2055 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2056 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2056 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2057 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2057 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2058 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2058 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2059 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2059 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2064 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2064 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2065 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2065 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2066 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2066 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2067 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2067 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2068 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2068 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2069 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2069 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2070 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2070 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2071 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2071 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2072 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2072 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2073 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2073 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2074 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2074 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2075 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2075 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2076 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2076 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2081 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2081 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2082 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2082 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2083 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2083 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2084 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2084 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2085 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2085 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2086 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2086 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2087 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2087 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2088 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2088 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2089 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2089 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2090 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2090 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2091 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2091 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2092 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2092 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2093 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2093 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2098 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2098 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2099 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2099 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2100 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2100 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2101 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2101 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2102 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2102 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2103 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2103 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2104 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2104 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2105 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2105 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2106 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2106 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2107 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2107 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2108 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2108 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2109 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2109 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2110 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2110 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2115 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2115 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2116 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2116 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2117 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2117 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2118 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2118 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2119 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2119 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2120 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2120 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2121 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2121 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2122 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2122 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2123 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2123 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2124 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2124 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2125 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2125 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2126 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2126 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2127 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2127 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2132 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2132 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2133 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2133 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2134 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2134 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2135 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2135 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2136 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2136 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2137 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2137 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2138 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2138 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2139 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2139 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2157 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2157 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2158 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2158 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2159 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2159 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2160 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2160 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2161 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2161 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2166 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2166 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2167 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2167 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2168 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2168 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2169 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2169 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2170 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2170 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2171 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2171 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2172 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2172 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2173 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2173 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2174 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2174 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2175 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2175 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2176 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2176 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2177 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2177 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2178 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2178 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2183 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2183 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2184 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2184 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2185 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2185 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2186 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2186 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2187 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2187 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2188 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2188 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2189 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2189 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2190 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2190 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2191 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2191 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2192 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2192 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2193 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2193 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2194 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2194 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2195 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2195 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2200 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2200 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2201 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2201 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2202 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2202 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2203 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2204 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2204 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2205 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2205 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2206 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2206 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2207 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2207 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2208 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2208 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2209 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2209 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2210 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2210 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2211 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2211 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2212 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2212 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2217 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2217 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2218 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2218 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2219 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2220 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2220 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2221 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2221 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2222 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2222 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2223 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2223 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2224 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2224 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2225 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2225 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2226 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2226 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2227 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2227 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2228 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2228 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2229 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2229 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2234 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2234 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2235 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2235 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2236 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2236 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2237 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2237 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2238 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2238 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2239 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2239 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2240 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2240 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2241 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2241 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2242 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2242 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2243 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2243 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2244 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2244 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2245 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2245 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2246 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2246 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2251 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2251 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2252 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2252 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2253 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2253 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2254 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2254 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2255 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2255 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2256 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2256 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2257 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2257 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2258 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2258 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2259 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2259 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2260 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2260 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2261 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2261 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2262 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2262 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2263 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2263 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2268 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2268 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2269 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2269 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2270 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2270 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2271 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2271 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2272 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2272 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2273 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2273 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2274 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2274 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2275 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2275 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2276 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2276 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2277 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2277 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2278 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2278 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2279 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2279 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2280 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2280 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2285 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2285 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2286 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2286 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2287 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2287 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2288 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2288 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2289 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2289 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2290 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2290 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2291 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2291 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2292 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2292 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2296 APFloat x(SpecialCaseTests[i].x);
2297 APFloat y(SpecialCaseTests[i].y);
2298 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2298 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2300 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2300 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2316 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2316 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2316 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2317 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2317 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2317 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2318 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2318 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2318 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2319 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2319 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2319 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2320 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2320 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2320 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2321 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2321 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2321 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2322 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2322 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2323 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2323 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2324 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2324 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2324 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2325 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2325 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2325 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2326 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2326 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2326 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2327 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2327 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2327 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2328 APFloat PSmallestNormalized =
2329 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2329 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2330 APFloat MSmallestNormalized =
2331 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2331 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2333 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2333 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2334 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2334 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2338 APFloat x;
2339 APFloat y;
2344 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2344 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2345 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2345 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2346 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2346 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2347 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2347 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2348 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2348 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2353 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2353 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2354 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2354 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2355 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2355 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2356 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2356 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2357 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2357 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2358 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2358 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2359 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2359 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2360 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2360 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2361 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2361 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2362 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2362 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2363 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2363 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2364 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2364 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2365 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2365 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2370 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2370 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2371 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2371 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2372 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2372 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2373 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2373 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2374 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2374 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2375 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2375 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2376 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2376 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2377 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2377 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2378 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2378 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2379 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2379 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2380 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2380 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2381 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2381 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2382 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2382 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2387 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2387 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2388 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2388 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2389 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2389 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2390 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2390 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2391 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2391 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2392 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2392 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2393 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2393 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2394 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2394 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2395 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2395 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2396 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2396 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2397 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2397 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2398 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2398 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2399 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2399 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2404 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2404 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2405 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2405 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2406 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2406 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2407 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2407 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2408 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2408 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2409 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2409 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2410 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2410 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2411 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2411 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2412 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2412 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2413 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2413 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2414 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2414 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2415 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2415 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2416 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2416 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2421 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2421 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2422 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2422 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2423 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2423 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2424 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2424 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2425 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2425 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2426 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2426 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2427 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2427 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2428 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2428 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2446 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2446 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2447 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2447 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2448 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2448 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2449 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2449 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2450 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2450 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2455 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2455 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2456 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2456 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2457 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2457 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2458 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2458 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2459 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2459 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2460 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2460 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2461 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2461 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2462 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2462 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2463 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2463 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2464 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2464 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2465 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2465 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2466 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2466 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2467 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2467 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2472 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2472 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2473 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2473 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2474 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2474 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2475 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2475 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2476 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2476 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2477 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2477 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2478 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2478 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2479 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2479 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2480 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2480 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2481 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2481 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2482 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2482 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2483 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2483 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2484 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2484 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2489 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2489 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2490 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2490 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2491 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2492 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2493 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2493 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2494 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2494 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2495 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2495 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2496 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2496 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2497 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2497 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2498 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2498 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2499 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2499 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2500 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2500 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2501 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2501 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2506 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2506 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2507 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2507 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2508 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2509 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2510 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2510 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2511 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2511 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2512 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2512 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2513 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2513 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2514 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2514 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2515 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2515 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2516 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2516 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2517 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2517 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2518 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2518 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2523 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2523 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2524 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2524 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2525 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2525 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2526 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2526 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2527 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2528 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2529 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2530 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2531 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2531 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2532 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2532 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2533 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2533 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2534 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2534 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2535 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2535 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2540 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2540 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2541 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2541 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2542 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2542 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2543 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2543 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2544 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2545 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2546 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2547 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2548 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2548 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2549 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2549 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2550 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2550 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2551 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2551 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2552 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2552 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2557 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2557 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2558 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2558 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2559 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2559 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2560 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2560 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2561 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2562 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2563 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2564 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2565 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2565 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2566 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2566 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2567 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2567 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2568 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2568 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2569 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2569 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2574 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2574 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2575 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2575 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2576 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2576 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2577 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2577 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2578 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2579 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2580 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2581 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2585 APFloat x(SpecialCaseTests[i].x);
2586 APFloat y(SpecialCaseTests[i].y);
2587 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2587 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2589 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2589 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2605 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2605 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2605 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2606 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2606 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2606 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2607 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2607 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2607 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2608 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2608 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2608 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2609 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2609 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2609 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2610 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2610 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2610 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2611 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2611 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2612 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2612 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2613 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2613 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2613 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2614 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2614 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2614 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2615 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2615 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2615 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2616 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2616 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2616 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2617 APFloat PSmallestNormalized =
2618 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2618 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2619 APFloat MSmallestNormalized =
2620 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2620 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2622 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2622 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2623 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2623 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2627 APFloat x;
2628 APFloat y;
2633 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2633 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2634 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2634 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2635 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2635 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2636 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2636 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2637 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2637 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2642 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2642 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2643 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2643 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2644 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2644 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2645 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2645 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2646 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2646 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2647 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2647 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2648 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2648 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2649 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2649 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2650 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2650 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2651 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2651 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2652 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2652 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2653 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2653 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2654 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2654 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2659 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2659 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2660 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2660 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2661 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2661 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2662 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2662 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2663 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2663 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2664 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2664 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2665 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2665 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2666 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2666 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2667 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2667 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2668 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2668 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2669 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2669 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2670 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2670 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2671 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2671 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2676 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2676 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2677 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2677 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2678 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2678 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2679 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2679 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2680 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2680 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2681 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2681 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2682 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2682 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2683 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2683 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2684 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2684 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2685 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2685 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2686 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2686 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2687 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2687 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2688 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2688 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2693 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2693 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2694 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2694 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2695 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2695 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2696 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2696 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2697 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2697 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2698 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2698 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2699 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2699 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2700 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2700 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2701 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2701 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2702 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2702 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2703 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2703 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2704 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2704 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2705 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2705 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2710 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2710 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2711 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2711 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2712 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2712 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2713 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2713 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2714 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2714 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2715 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2715 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2716 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2716 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2717 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2717 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2735 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2735 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2736 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2736 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2737 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2737 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2738 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2738 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2739 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2739 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2744 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2744 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2745 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2745 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2746 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2747 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2748 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2749 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2750 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2750 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2751 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2751 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2752 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2752 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2753 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2753 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2754 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2754 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2755 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2755 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2756 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2756 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2761 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2761 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2762 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2762 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2763 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2764 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2765 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2766 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2767 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2767 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2768 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2768 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2769 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2769 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2770 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2770 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2771 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2771 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2772 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2772 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2773 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2773 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2778 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2778 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2779 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2779 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2780 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2780 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2781 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2781 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2782 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2783 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2784 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2785 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2786 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2786 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2787 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2787 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2788 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2788 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2789 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2789 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2790 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2790 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2795 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2795 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2796 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2796 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2797 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2797 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2798 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2798 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2799 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2800 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2801 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2802 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2803 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2803 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2804 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2804 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2805 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2805 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2806 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2806 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2807 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2807 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2812 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2812 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2813 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2813 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2814 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2815 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2816 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2816 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2817 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2817 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2818 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2818 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2819 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2819 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2820 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2820 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2821 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2821 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2822 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2822 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2823 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2823 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2824 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2824 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2829 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2829 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2830 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2830 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2831 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2832 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2833 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2833 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2834 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2834 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2835 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2835 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2836 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2836 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2837 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2837 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2838 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2838 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2839 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2839 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2840 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2840 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2841 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2841 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2846 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2846 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2847 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2847 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2848 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2849 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2850 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2850 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2851 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2851 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2852 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2852 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2853 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2853 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2854 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2854 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2855 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2855 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2856 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2856 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2857 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2857 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2858 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2858 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2863 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2863 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2864 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2864 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2865 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2866 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2867 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2867 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2868 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2868 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2869 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2869 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2870 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2870 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2874 APFloat x(SpecialCaseTests[i].x);
2875 APFloat y(SpecialCaseTests[i].y);
2876 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2876 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2878 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2878 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2888 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2888 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2889 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
2889 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
2897 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2897 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2897 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2898 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2898 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2898 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2899 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2899 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2899 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2900 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2900 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2900 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2901 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2901 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2901 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2902 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2902 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2902 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2903 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2903 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2903 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2904 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
2904 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
2904 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
2905 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2905 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2906 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2906 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2907 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2907 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2907 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2908 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2908 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2908 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2909 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2909 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2909 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2910 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2910 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2910 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2911 APFloat PSmallestNormalized =
2912 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2912 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2913 APFloat MSmallestNormalized =
2914 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2914 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2935 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
2935 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
2936 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
2936 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
2937 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
2937 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
2937 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
2938 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2938 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2938 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2939 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
2939 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
2939 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
2940 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2940 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2940 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2941 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2941 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2941 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2942 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2942 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2942 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3001 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3001 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3012 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3012 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3012 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3013 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3013 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3013 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3014 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3014 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3014 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3015 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3015 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3015 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3016 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3016 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3016 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3017 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3017 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3017 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3018 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3018 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3018 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3028 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
3037 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3037 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3037 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3039 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
3059 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3059 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3059 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3060 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3060 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3060 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3062 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3062 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3062 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3063 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3063 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3063 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3065 APFloat SmallestNormalizedF64
3066 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3066 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3067 APFloat NegSmallestNormalizedF64
3068 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3068 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3070 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3070 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3071 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3071 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3126 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3126 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3171 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3171 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3173 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3173 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3173 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3174 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3174 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3174 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3175 APFloat One(1.0);
3176 APFloat MOne(-1.0);
3177 APFloat Two(2.0);
3178 APFloat MTwo(-2.0);
3180 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3180 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3181 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3181 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3183 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3183 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3183 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3184 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3184 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3184 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3186 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3186 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3186 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3187 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3187 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3187 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3189 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3189 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3189 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3190 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3190 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3190 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3192 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3192 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3192 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3193 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3193 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3193 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3194 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3194 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3194 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3202 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3202 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3202 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3205 APFloat SmallestNormalized
3206 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3206 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3207 APFloat NegSmallestNormalized
3208 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3208 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3211 APFloat Frac(APFloat::IEEEdouble());
3211 APFloat Frac(APFloat::IEEEdouble());
3283 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3287 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3291 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3298 APFloat f1(APFloat::IEEEdouble(), "1.5");
3298 APFloat f1(APFloat::IEEEdouble(), "1.5");
3299 APFloat f2(APFloat::IEEEdouble(), "1.0");
3299 APFloat f2(APFloat::IEEEdouble(), "1.0");
3300 APFloat expected(APFloat::IEEEdouble(), "0.5");
3300 APFloat expected(APFloat::IEEEdouble(), "0.5");
3305 APFloat f1(APFloat::IEEEdouble(), "0.5");
3305 APFloat f1(APFloat::IEEEdouble(), "0.5");
3306 APFloat f2(APFloat::IEEEdouble(), "1.0");
3306 APFloat f2(APFloat::IEEEdouble(), "1.0");
3307 APFloat expected(APFloat::IEEEdouble(), "0.5");
3307 APFloat expected(APFloat::IEEEdouble(), "0.5");
3312 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
3312 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
3313 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
3313 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
3314 APFloat expected(APFloat::IEEEdouble(),
3314 APFloat expected(APFloat::IEEEdouble(),
3320 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
3320 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
3321 APFloat f2(APFloat::IEEEdouble(), "1.5");
3321 APFloat f2(APFloat::IEEEdouble(), "1.5");
3322 APFloat expected(APFloat::IEEEdouble(), "1.0");
3322 APFloat expected(APFloat::IEEEdouble(), "1.0");
3327 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
3327 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
3328 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
3328 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
3329 APFloat expected(APFloat::IEEEdouble(), "0.0");
3329 APFloat expected(APFloat::IEEEdouble(), "0.0");
3334 APFloat f1(APFloat::IEEEdouble(), "0.0");
3334 APFloat f1(APFloat::IEEEdouble(), "0.0");
3335 APFloat f2(APFloat::IEEEdouble(), "1.0");
3335 APFloat f2(APFloat::IEEEdouble(), "1.0");
3336 APFloat expected(APFloat::IEEEdouble(), "0.0");
3336 APFloat expected(APFloat::IEEEdouble(), "0.0");
3341 APFloat f1(APFloat::IEEEdouble(), "1.0");
3341 APFloat f1(APFloat::IEEEdouble(), "1.0");
3342 APFloat f2(APFloat::IEEEdouble(), "0.0");
3342 APFloat f2(APFloat::IEEEdouble(), "0.0");
3347 APFloat f1(APFloat::IEEEdouble(), "0.0");
3347 APFloat f1(APFloat::IEEEdouble(), "0.0");
3348 APFloat f2(APFloat::IEEEdouble(), "0.0");
3348 APFloat f2(APFloat::IEEEdouble(), "0.0");
3353 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3353 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3353 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3354 APFloat f2(APFloat::IEEEdouble(), "1.0");
3354 APFloat f2(APFloat::IEEEdouble(), "1.0");
3359 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3359 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3360 APFloat f2(APFloat::IEEEdouble(), "-2.0");
3360 APFloat f2(APFloat::IEEEdouble(), "-2.0");
3361 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3361 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3366 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3366 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3367 APFloat f2(APFloat::IEEEdouble(), "2.0");
3367 APFloat f2(APFloat::IEEEdouble(), "2.0");
3368 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3368 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3376 APFloat::fltCategory, APFloat::roundingMode>;
3376 APFloat::fltCategory, APFloat::roundingMode>;
3380 APFloat::fcZero, APFloat::rmNearestTiesToEven),
3380 APFloat::fcZero, APFloat::rmNearestTiesToEven),
3383 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
3384 APFloat::rmNearestTiesToEven),
3391 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
3391 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
3395 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3395 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3398 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3398 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3403 APFloat::fltCategory Expected;
3404 APFloat::roundingMode RM;
3408 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3408 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3409 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3409 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3418 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3418 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3419 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3419 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3432 uint64_t, APFloat::roundingMode>;
3437 APFloat::rmNearestTiesToEven),
3441 APFloat::rmNearestTiesToEven),
3445 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
3449 APFloat::rmNearestTiesToEven),
3456 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3463 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3468 APFloat::roundingMode RM;
3472 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3472 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3473 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3473 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3486 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3486 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3487 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3487 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3504 uint64_t, APFloat::roundingMode>;
3509 APFloat::rmNearestTiesToEven),
3513 APFloat::rmNearestTiesToEven),
3518 APFloat::roundingMode RM;
3521 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3521 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3522 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3522 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3538 APFloat::fltCategory, APFloat::roundingMode>;
3538 APFloat::fltCategory, APFloat::roundingMode>;
3542 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3542 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3544 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
3545 APFloat::rmNearestTiesToEven),
3548 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3548 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3551 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3551 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3554 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3554 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3556 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
3557 APFloat::rmNearestTiesToEven),
3560 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3560 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3562 std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
3563 APFloat::rmNearestTiesToEven),
3565 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
3566 APFloat::rmNearestTiesToEven),
3571 APFloat::fltCategory Expected;
3572 APFloat::roundingMode RM;
3576 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3576 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3577 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3577 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3586 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3586 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3587 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3587 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3600 uint64_t, APFloat::roundingMode>;
3605 APFloat::rmNearestTiesToEven),
3609 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
3614 APFloat::rmNearestTiesToEven),
3618 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
3622 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
3626 APFloat::rmNearestTiesToEven),
3630 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
3635 APFloat::rmNearestTiesToEven),
3640 APFloat::rmNearestTiesToEven),
3645 APFloat::roundingMode RM;
3649 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3649 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3650 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3650 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3663 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3663 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3664 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3664 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3681 uint64_t, APFloat::roundingMode>;
3688 APFloat::rmNearestTiesToEven),
3693 APFloat::roundingMode RM;
3696 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3696 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3697 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3697 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3729 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3729 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3730 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3730 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3764 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3764 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3765 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3765 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3781 APFloat A(APFloat::PPCDoubleDouble(), "2");
3781 APFloat A(APFloat::PPCDoubleDouble(), "2");
3782 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
3783 APFloat(APFloat::PPCDoubleDouble(), "4"),
3784 APFloat::rmNearestTiesToEven);
3791 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
3791 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
3792 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3797 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
3797 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
3798 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3806 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
3811 APFloat::cmpEqual),
3814 APFloat::cmpLessThan),
3817 APFloat::cmpGreaterThan),
3820 0x0000000000000001ull, APFloat::cmpLessThan),
3823 APFloat::cmpUnordered),
3826 APFloat::cmpUnordered),
3829 APFloat::cmpEqual),
3834 APFloat::cmpResult Expected;
3837 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3837 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3838 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3838 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3869 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3869 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3870 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3870 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3891 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
3891 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
3893 APFloat Actual =
3894 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
3894 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
3899 APFloat Actual =
3900 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
3900 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
3991 APFloat Result =
3992 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
3993 APFloat::rmNearestTiesToEven);
4006 APFloat Result =
4007 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
4008 APFloat::rmNearestTiesToEven);
unittests/CodeGen/GlobalISel/MachineIRBuilderTest.cpp 24 APFloat KVal(APFloat::IEEEdouble(), "4.0");
24 APFloat KVal(APFloat::IEEEdouble(), "4.0");
65 APFloat DoubleVal(APFloat::IEEEdouble());
65 APFloat DoubleVal(APFloat::IEEEdouble());
unittests/CodeGen/GlobalISel/PatternMatchTest.cpp 163 APFloat APF((float).5);
174 APFloat APF64(.5);
187 APFloat APF16(.5);
188 APF16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
188 APF16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
72 constexpr _Tp&&
83 constexpr _Tp&&
98 move(_Tp&& __t) noexcept
104 : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
105 is_copy_constructible<_Tp>>::type { };
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
97 _Destroy(_Tp* __pointer)
204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_iterator.h 1224 __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
192 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
usr/include/c++/7.4.0/bits/stl_pair.h 209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
214 _T1 first; /// @c first is a copy of the first object
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
325 constexpr pair(const _T1& __x, _U2&& __y)
332 explicit pair(const _T1& __x, _U2&& __y)
379 __and_<is_copy_assignable<_T1>,
390 __and_<is_move_assignable<_T1>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
416 operator=(pair<_U1, _U2>&& __p)
usr/include/c++/7.4.0/bits/stl_uninitialized.h 288 _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
1483 _M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/bits/unique_ptr.h 103 default_delete(const default_delete<_Up[]>&) noexcept { }
107 typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
107 typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
108 operator()(_Up* __ptr) const
110 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
401 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
403 __uniq_ptr_impl<_Tp, _Dp> _M_t;
411 = __and_< is_base_of<_Tp, _Up>,
412 __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
412 __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
412 __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
415 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
416 using element_type = _Tp;
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
111 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
130 { return size_t(-1) / sizeof(_Tp); }
135 construct(_Up* __p, _Args&&... __args)
135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
1983 { typedef _Up type; };