reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/ADT/APFloat.h
  794     if (usesLayout<IEEEFloat>(*U.semantics))
  795       return U.IEEE;
  796     if (usesLayout<DoubleAPFloat>(*U.semantics))
  797       return U.Double.getFirst().U.IEEE;
  797       return U.Double.getFirst().U.IEEE;
  802     if (usesLayout<IEEEFloat>(*U.semantics))
  803       return U.IEEE;
  804     if (usesLayout<DoubleAPFloat>(*U.semantics))
  805       return U.Double.getFirst().U.IEEE;
  805       return U.Double.getFirst().U.IEEE;
  809   void makeZero(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeZero(Neg)); }
  811   void makeInf(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeInf(Neg)); }
  814     APFLOAT_DISPATCH_ON_SEMANTICS(makeNaN(SNaN, Neg, fill));
  818     APFLOAT_DISPATCH_ON_SEMANTICS(makeLargest(Neg));
  822     APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg));
  826     APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallestNormalized(Neg));
  844       return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
  844       return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
  846       return U.Double.compareAbsoluteValue(RHS.U.Double);
  846       return U.Double.compareAbsoluteValue(RHS.U.Double);
  865   bool needsCleanup() const { APFLOAT_DISPATCH_ON_SEMANTICS(needsCleanup()); }
  960       return U.IEEE.add(RHS.U.IEEE, RM);
  960       return U.IEEE.add(RHS.U.IEEE, RM);
  962       return U.Double.add(RHS.U.Double, RM);
  962       return U.Double.add(RHS.U.Double, RM);
  969       return U.IEEE.subtract(RHS.U.IEEE, RM);
  969       return U.IEEE.subtract(RHS.U.IEEE, RM);
  971       return U.Double.subtract(RHS.U.Double, RM);
  971       return U.Double.subtract(RHS.U.Double, RM);
  978       return U.IEEE.multiply(RHS.U.IEEE, RM);
  978       return U.IEEE.multiply(RHS.U.IEEE, RM);
  980       return U.Double.multiply(RHS.U.Double, RM);
  980       return U.Double.multiply(RHS.U.Double, RM);
  987       return U.IEEE.divide(RHS.U.IEEE, RM);
  987       return U.IEEE.divide(RHS.U.IEEE, RM);
  989       return U.Double.divide(RHS.U.Double, RM);
  989       return U.Double.divide(RHS.U.Double, RM);
  996       return U.IEEE.remainder(RHS.U.IEEE);
  996       return U.IEEE.remainder(RHS.U.IEEE);
  998       return U.Double.remainder(RHS.U.Double);
  998       return U.Double.remainder(RHS.U.Double);
 1005       return U.IEEE.mod(RHS.U.IEEE);
 1005       return U.IEEE.mod(RHS.U.IEEE);
 1007       return U.Double.mod(RHS.U.Double);
 1007       return U.Double.mod(RHS.U.Double);
 1017       return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
 1017       return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
 1017       return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
 1019       return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
 1019       return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
 1019       return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
 1024     APFLOAT_DISPATCH_ON_SEMANTICS(roundToIntegral(RM));
 1030     APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown));
 1065   void changeSign() { APFLOAT_DISPATCH_ON_SEMANTICS(changeSign()); }
 1087     APFLOAT_DISPATCH_ON_SEMANTICS(
 1094     APFLOAT_DISPATCH_ON_SEMANTICS(convertFromAPInt(Input, IsSigned, RM));
 1099     APFLOAT_DISPATCH_ON_SEMANTICS(
 1105     APFLOAT_DISPATCH_ON_SEMANTICS(
 1110     APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt());
 1121       return U.IEEE.compare(RHS.U.IEEE);
 1121       return U.IEEE.compare(RHS.U.IEEE);
 1123       return U.Double.compare(RHS.U.Double);
 1123       return U.Double.compare(RHS.U.Double);
 1131       return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
 1131       return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
 1133       return U.Double.bitwiseIsEqual(RHS.U.Double);
 1133       return U.Double.bitwiseIsEqual(RHS.U.Double);
 1154     APFLOAT_DISPATCH_ON_SEMANTICS(
 1163   bool isDenormal() const { APFLOAT_DISPATCH_ON_SEMANTICS(isDenormal()); }
 1170   const fltSemantics &getSemantics() const { return *U.semantics; }
 1175   bool isSmallest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isSmallest()); }
 1176   bool isLargest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isLargest()); }
 1177   bool isInteger() const { APFLOAT_DISPATCH_ON_SEMANTICS(isInteger()); }
 1179   APFloat &operator=(const APFloat &RHS) = default;
 1180   APFloat &operator=(APFloat &&RHS) = default;
 1184     APFLOAT_DISPATCH_ON_SEMANTICS(
 1192     APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
 1210     return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
 1212     return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics());
 1222     return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics());
 1224     return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics());
lib/Support/APFloat.cpp
 4467   APFLOAT_DISPATCH_ON_SEMANTICS(convertFromString(Str, RM));
 4472     return hash_value(Arg.U.IEEE);
 4474     return hash_value(Arg.U.Double);
 4491     return U.IEEE.convert(ToSemantics, RM, losesInfo);
 4495     auto Ret = U.IEEE.convert(semPPCDoubleDoubleLegacy, RM, losesInfo);
 4496     *this = APFloat(ToSemantics, U.IEEE.bitcastToAPInt());