/build/source/llvm/lib/Support/APFloat.cpp

Bug Summary

File:	build/source/llvm/lib/Support/APFloat.cpp
Warning:	line 5084, column 24 Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name APFloat.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Support -I /build/source/llvm/lib/Support -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/llvm/lib/Support/APFloat.cpp

/build/source/llvm/lib/Support/APFloat.cpp

→

1//===-- APFloat.cpp - Implement APFloat class -----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements a class to represent arbitrary precision floating
10// point values and provide a variety of arithmetic operations on them.
11//
12//===----------------------------------------------------------------------===//

14#include "llvm/ADT/APFloat.h"
15#include "llvm/ADT/APSInt.h"
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/FloatingPointMode.h"
18#include "llvm/ADT/FoldingSet.h"
19#include "llvm/ADT/Hashing.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/Config/llvm-config.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/Error.h"
26#include "llvm/Support/MathExtras.h"
27#include "llvm/Support/raw_ostream.h"
28#include <cstring>
29#include <limits.h>

31#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)                             \
do {                                                                         \
  if (usesLayout<IEEEFloat>(getSemantics()))                                 \
    return U.IEEE.METHOD_CALL;                                               \
  if (usesLayout<DoubleAPFloat>(getSemantics()))                             \
    return U.Double.METHOD_CALL;                                             \
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/lib/Support/APFloat.cpp"
, 37);                                  \
} while (false)

40using namespace llvm;

42/// A macro used to combine two fcCategory enums into one key which can be used
43/// in a switch statement to classify how the interaction of two APFloat's
44/// categories affects an operation.
45///
46/// TODO: If clang source code is ever allowed to use constexpr in its own
47/// codebase, change this into a static inline function.
48#define PackCategoriesIntoKey(_lhs, _rhs)((_lhs) * 4 + (_rhs)) ((_lhs) * 4 + (_rhs))

50/* Assumed in hexadecimal significand parsing, and conversion to
 hexadecimal strings.  */
52static_assert(APFloatBase::integerPartWidth % 4 == 0, "Part width must be divisible by 4!");

54namespace llvm {

56// How the nonfinite values Inf and NaN are represented.
57enum class fltNonfiniteBehavior {
// Represents standard IEEE 754 behavior. A value is nonfinite if the
// exponent field is all 1s. In such cases, a value is Inf if the
// significand bits are all zero, and NaN otherwise
IEEE754,

// This behavior is present in the Float8ExMyFN* types (Float8E4M3FN,
// Float8E5M2FNUZ, Float8E4M3FNUZ, and Float8E4M3B11FNUZ). There is no
// representation for Inf, and operations that would ordinarily produce Inf
// produce NaN instead.
// The details of the NaN representation(s) in this form are determined by the
// `fltNanEncoding` enum. We treat all NaNs as quiet, as the available
// encodings do not distinguish between signalling and quiet NaN.
NanOnly,
71};

73// How NaN values are represented. This is curently only used in combination
74// with fltNonfiniteBehavior::NanOnly, and using a variant other than IEEE
75// while having IEEE non-finite behavior is liable to lead to unexpected
76// results.
77enum class fltNanEncoding {
// Represents the standard IEEE behavior where a value is NaN if its
// exponent is all 1s and the significand is non-zero.
IEEE,

// Represents the behavior in the Float8E4M3 floating point type where NaN is
// represented by having the exponent and mantissa set to all 1s.
// This behavior matches the FP8 E4M3 type described in
// https://arxiv.org/abs/2209.05433. We treat both signed and unsigned NaNs
// as non-signalling, although the paper does not state whether the NaN
// values are signalling or not.
AllOnes,

// Represents the behavior in Float8E{5,4}E{2,3}FNUZ floating point types
// where NaN is represented by a sign bit of 1 and all 0s in the exponent
// and mantissa (i.e. the negative zero encoding in a IEEE float). Since
// there is only one NaN value, it is treated as quiet NaN. This matches the
// behavior described in https://arxiv.org/abs/2206.02915 .
NegativeZero,
96};

98/* Represents floating point arithmetic semantics.  */
99struct fltSemantics {
/* The largest E such that 2^E is representable; this matches the
   definition of IEEE 754.  */
APFloatBase::ExponentType maxExponent;

/* The smallest E such that 2^E is a normalized number; this
   matches the definition of IEEE 754.  */
APFloatBase::ExponentType minExponent;

/* Number of bits in the significand.  This includes the integer
   bit.  */
unsigned int precision;

/* Number of bits actually used in the semantics. */
unsigned int sizeInBits;

fltNonfiniteBehavior nonFiniteBehavior = fltNonfiniteBehavior::IEEE754;

fltNanEncoding nanEncoding = fltNanEncoding::IEEE;
// Returns true if any number described by this semantics can be precisely
// represented by the specified semantics. Does not take into account
// the value of fltNonfiniteBehavior.
bool isRepresentableBy(const fltSemantics &S) const {
  return maxExponent <= S.maxExponent && minExponent >= S.minExponent &&
         precision <= S.precision;
}
125};

127static constexpr fltSemantics semIEEEhalf = {15, -14, 11, 16};
128static constexpr fltSemantics semBFloat = {127, -126, 8, 16};
129static constexpr fltSemantics semIEEEsingle = {127, -126, 24, 32};
130static constexpr fltSemantics semIEEEdouble = {1023, -1022, 53, 64};
131static constexpr fltSemantics semIEEEquad = {16383, -16382, 113, 128};
132static constexpr fltSemantics semFloat8E5M2 = {15, -14, 3, 8};
133static constexpr fltSemantics semFloat8E5M2FNUZ = {
  15, -15, 3, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::NegativeZero};
135static constexpr fltSemantics semFloat8E4M3FN = {
  8, -6, 4, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::AllOnes};
137static constexpr fltSemantics semFloat8E4M3FNUZ = {
  7, -7, 4, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::NegativeZero};
139static constexpr fltSemantics semFloat8E4M3B11FNUZ = {
  4, -10, 4, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::NegativeZero};
141static constexpr fltSemantics semX87DoubleExtended = {16383, -16382, 64, 80};
142static constexpr fltSemantics semBogus = {0, 0, 0, 0};

144/* The IBM double-double semantics. Such a number consists of a pair of IEEE
 64-bit doubles (Hi, Lo), where |Hi| > |Lo|, and if normal,
 (double)(Hi + Lo) == Hi. The numeric value it's modeling is Hi + Lo.
 Therefore it has two 53-bit mantissa parts that aren't necessarily adjacent
 to each other, and two 11-bit exponents.

 Note: we need to make the value different from semBogus as otherwise
 an unsafe optimization may collapse both values to a single address,
 and we heavily rely on them having distinct addresses.             */
153static constexpr fltSemantics semPPCDoubleDouble = {-1, 0, 0, 128};

155/* These are legacy semantics for the fallback, inaccrurate implementation of
 IBM double-double, if the accurate semPPCDoubleDouble doesn't handle the
 operation. It's equivalent to having an IEEE number with consecutive 106
 bits of mantissa and 11 bits of exponent.

 It's not equivalent to IBM double-double. For example, a legit IBM
 double-double, 1 + epsilon:

   1 + epsilon = 1 + (1 >> 1076)

 is not representable by a consecutive 106 bits of mantissa.

 Currently, these semantics are used in the following way:

   semPPCDoubleDouble -> (IEEEdouble, IEEEdouble) ->
   (64-bit APInt, 64-bit APInt) -> (128-bit APInt) ->
   semPPCDoubleDoubleLegacy -> IEEE operations

 We use bitcastToAPInt() to get the bit representation (in APInt) of the
 underlying IEEEdouble, then use the APInt constructor to construct the
 legacy IEEE float.

 TODO: Implement all operations in semPPCDoubleDouble, and delete these
 semantics.  */
179static constexpr fltSemantics semPPCDoubleDoubleLegacy = {1023, -1022 + 53,
                                                        53 + 53, 128};

182const llvm::fltSemantics &APFloatBase::EnumToSemantics(Semantics S) {
switch (S) {
case S_IEEEhalf:
  return IEEEhalf();
case S_BFloat:
  return BFloat();
case S_IEEEsingle:
  return IEEEsingle();
case S_IEEEdouble:
  return IEEEdouble();
case S_IEEEquad:
  return IEEEquad();
case S_PPCDoubleDouble:
  return PPCDoubleDouble();
case S_Float8E5M2:
  return Float8E5M2();
case S_Float8E5M2FNUZ:
  return Float8E5M2FNUZ();
case S_Float8E4M3FN:
  return Float8E4M3FN();
case S_Float8E4M3FNUZ:
  return Float8E4M3FNUZ();
case S_Float8E4M3B11FNUZ:
  return Float8E4M3B11FNUZ();
case S_x87DoubleExtended:
  return x87DoubleExtended();
}
llvm_unreachable("Unrecognised floating semantics")::llvm::llvm_unreachable_internal("Unrecognised floating semantics"
, "llvm/lib/Support/APFloat.cpp", 209);
210}

212APFloatBase::Semantics
213APFloatBase::SemanticsToEnum(const llvm::fltSemantics &Sem) {
if (&Sem == &llvm::APFloat::IEEEhalf())
  return S_IEEEhalf;
else if (&Sem == &llvm::APFloat::BFloat())
  return S_BFloat;
else if (&Sem == &llvm::APFloat::IEEEsingle())
  return S_IEEEsingle;
else if (&Sem == &llvm::APFloat::IEEEdouble())
  return S_IEEEdouble;
else if (&Sem == &llvm::APFloat::IEEEquad())
  return S_IEEEquad;
else if (&Sem == &llvm::APFloat::PPCDoubleDouble())
  return S_PPCDoubleDouble;
else if (&Sem == &llvm::APFloat::Float8E5M2())
  return S_Float8E5M2;
else if (&Sem == &llvm::APFloat::Float8E5M2FNUZ())
  return S_Float8E5M2FNUZ;
else if (&Sem == &llvm::APFloat::Float8E4M3FN())
  return S_Float8E4M3FN;
else if (&Sem == &llvm::APFloat::Float8E4M3FNUZ())
  return S_Float8E4M3FNUZ;
else if (&Sem == &llvm::APFloat::Float8E4M3B11FNUZ())
  return S_Float8E4M3B11FNUZ;
else if (&Sem == &llvm::APFloat::x87DoubleExtended())
  return S_x87DoubleExtended;
else
  llvm_unreachable("Unknown floating semantics")::llvm::llvm_unreachable_internal("Unknown floating semantics"
, "llvm/lib/Support/APFloat.cpp", 239);
240}

242const fltSemantics &APFloatBase::IEEEhalf() { return semIEEEhalf; }
243const fltSemantics &APFloatBase::BFloat() { return semBFloat; }
244const fltSemantics &APFloatBase::IEEEsingle() { return semIEEEsingle; }
245const fltSemantics &APFloatBase::IEEEdouble() { return semIEEEdouble; }
246const fltSemantics &APFloatBase::IEEEquad() { return semIEEEquad; }
247const fltSemantics &APFloatBase::PPCDoubleDouble() {
return semPPCDoubleDouble;
249}
250const fltSemantics &APFloatBase::Float8E5M2() { return semFloat8E5M2; }
251const fltSemantics &APFloatBase::Float8E5M2FNUZ() { return semFloat8E5M2FNUZ; }
252const fltSemantics &APFloatBase::Float8E4M3FN() { return semFloat8E4M3FN; }
253const fltSemantics &APFloatBase::Float8E4M3FNUZ() { return semFloat8E4M3FNUZ; }
254const fltSemantics &APFloatBase::Float8E4M3B11FNUZ() {
return semFloat8E4M3B11FNUZ;
256}
257const fltSemantics &APFloatBase::x87DoubleExtended() {
return semX87DoubleExtended;
259}
260const fltSemantics &APFloatBase::Bogus() { return semBogus; }

262constexpr RoundingMode APFloatBase::rmNearestTiesToEven;
263constexpr RoundingMode APFloatBase::rmTowardPositive;
264constexpr RoundingMode APFloatBase::rmTowardNegative;
265constexpr RoundingMode APFloatBase::rmTowardZero;
266constexpr RoundingMode APFloatBase::rmNearestTiesToAway;

268/* A tight upper bound on number of parts required to hold the value
 pow(5, power) is

   power * 815 / (351 * integerPartWidth) + 1

 However, whilst the result may require only this many parts,
 because we are multiplying two values to get it, the
 multiplication may require an extra part with the excess part
 being zero (consider the trivial case of 1 * 1, tcFullMultiply
 requires two parts to hold the single-part result).  So we add an
 extra one to guarantee enough space whilst multiplying.  */
279const unsigned int maxExponent = 16383;
280const unsigned int maxPrecision = 113;
281const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
282const unsigned int maxPowerOfFiveParts =
  2 +
  ((maxPowerOfFiveExponent * 815) / (351 * APFloatBase::integerPartWidth));

286unsigned int APFloatBase::semanticsPrecision(const fltSemantics &semantics) {
return semantics.precision;
288}
289APFloatBase::ExponentType
290APFloatBase::semanticsMaxExponent(const fltSemantics &semantics) {
return semantics.maxExponent;
292}
293APFloatBase::ExponentType
294APFloatBase::semanticsMinExponent(const fltSemantics &semantics) {
return semantics.minExponent;
296}
297unsigned int APFloatBase::semanticsSizeInBits(const fltSemantics &semantics) {
return semantics.sizeInBits;
299}
300unsigned int APFloatBase::semanticsIntSizeInBits(const fltSemantics &semantics,
                                               bool isSigned) {
// The max FP value is pow(2, MaxExponent) * (1 + MaxFraction), so we need
// at least one more bit than the MaxExponent to hold the max FP value.
unsigned int MinBitWidth = semanticsMaxExponent(semantics) + 1;
// Extra sign bit needed.
if (isSigned)
  ++MinBitWidth;
return MinBitWidth;
309}

311bool APFloatBase::isRepresentableAsNormalIn(const fltSemantics &Src,
                                          const fltSemantics &Dst) {
// Exponent range must be larger.
if (Src.maxExponent >= Dst.maxExponent || Src.minExponent <= Dst.minExponent)
  return false;

// If the mantissa is long enough, the result value could still be denormal
// with a larger exponent range.
//
// FIXME: This condition is probably not accurate but also shouldn't be a
// practical concern with existing types.
return Dst.precision >= Src.precision;
323}

325unsigned APFloatBase::getSizeInBits(const fltSemantics &Sem) {
return Sem.sizeInBits;
327}

329static constexpr APFloatBase::ExponentType
330exponentZero(const fltSemantics &semantics) {
return semantics.minExponent - 1;
332}

334static constexpr APFloatBase::ExponentType
335exponentInf(const fltSemantics &semantics) {
return semantics.maxExponent + 1;
337}

339static constexpr APFloatBase::ExponentType
340exponentNaN(const fltSemantics &semantics) {
if (semantics.nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
  if (semantics.nanEncoding == fltNanEncoding::NegativeZero)
    return exponentZero(semantics);
  return semantics.maxExponent;
}
return semantics.maxExponent + 1;
347}

349/* A bunch of private, handy routines.  */

351static inline Error createError(const Twine &Err) {
return make_error<StringError>(Err, inconvertibleErrorCode());
353}

355static constexpr inline unsigned int partCountForBits(unsigned int bits) {
return ((bits) + APFloatBase::integerPartWidth - 1) / APFloatBase::integerPartWidth;
357}

359/* Returns 0U-9U.  Return values >= 10U are not digits.  */
360static inline unsigned int
361decDigitValue(unsigned int c)
362{
return c - '0';
364}

366/* Return the value of a decimal exponent of the form
 [+-]ddddddd.

 If the exponent overflows, returns a large exponent with the
 appropriate sign.  */
371static Expected<int> readExponent(StringRef::iterator begin,
                                StringRef::iterator end) {
bool isNegative;
unsigned int absExponent;
const unsigned int overlargeExponent = 24000;  /* FIXME.  */
StringRef::iterator p = begin;

// Treat no exponent as 0 to match binutils
if (p == end || ((*p == '-' || *p == '+') && (p + 1) == end)) {
  return 0;
}

isNegative = (*p == '-');
if (*p == '-' || *p == '+') {
  p++;
  if (p == end)
    return createError("Exponent has no digits");
}

absExponent = decDigitValue(*p++);
if (absExponent >= 10U)
  return createError("Invalid character in exponent");

for (; p != end; ++p) {
  unsigned int value;

  value = decDigitValue(*p);
  if (value >= 10U)
    return createError("Invalid character in exponent");

  absExponent = absExponent * 10U + value;
  if (absExponent >= overlargeExponent) {
    absExponent = overlargeExponent;
    break;
  }
}

if (isNegative)
  return -(int) absExponent;
else
  return (int) absExponent;
412}

414/* This is ugly and needs cleaning up, but I don't immediately see
 how whilst remaining safe.  */
416static Expected<int> totalExponent(StringRef::iterator p,
                                 StringRef::iterator end,
                                 int exponentAdjustment) {
int unsignedExponent;
bool negative, overflow;
int exponent = 0;

if (p == end)
  return createError("Exponent has no digits");

negative = *p == '-';
if (*p == '-' || *p == '+') {
  p++;
  if (p == end)
    return createError("Exponent has no digits");
}

unsignedExponent = 0;
overflow = false;
for (; p != end; ++p) {
  unsigned int value;

  value = decDigitValue(*p);
  if (value >= 10U)
    return createError("Invalid character in exponent");

  unsignedExponent = unsignedExponent * 10 + value;
  if (unsignedExponent > 32767) {
    overflow = true;
    break;
  }
}

if (exponentAdjustment > 32767 || exponentAdjustment < -32768)
  overflow = true;

if (!overflow) {
  exponent = unsignedExponent;
  if (negative)
    exponent = -exponent;
  exponent += exponentAdjustment;
  if (exponent > 32767 || exponent < -32768)
    overflow = true;
}

if (overflow)
  exponent = negative ? -32768: 32767;

return exponent;
465}

467static Expected<StringRef::iterator>
468skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
                         StringRef::iterator *dot) {
StringRef::iterator p = begin;
*dot = end;
while (p != end && *p == '0')
  p++;

if (p != end && *p == '.') {
  *dot = p++;

  if (end - begin == 1)
    return createError("Significand has no digits");

  while (p != end && *p == '0')
    p++;
}

return p;
486}

488/* Given a normal decimal floating point number of the form

   dddd.dddd[eE][+-]ddd

 where the decimal point and exponent are optional, fill out the
 structure D.  Exponent is appropriate if the significand is
 treated as an integer, and normalizedExponent if the significand
 is taken to have the decimal point after a single leading
 non-zero digit.

 If the value is zero, V->firstSigDigit points to a non-digit, and
 the return exponent is zero.
500*/
501struct decimalInfo {
const char *firstSigDigit;
const char *lastSigDigit;
int exponent;
int normalizedExponent;
506};

508static Error interpretDecimal(StringRef::iterator begin,
                            StringRef::iterator end, decimalInfo *D) {
StringRef::iterator dot = end;

auto PtrOrErr = skipLeadingZeroesAndAnyDot(begin, end, &dot);
if (!PtrOrErr)
  return PtrOrErr.takeError();
StringRef::iterator p = *PtrOrErr;

D->firstSigDigit = p;
D->exponent = 0;
D->normalizedExponent = 0;

for (; p != end; ++p) {
  if (*p == '.') {
    if (dot != end)
      return createError("String contains multiple dots");
    dot = p++;
    if (p == end)
      break;
  }
  if (decDigitValue(*p) >= 10U)
    break;
}

if (p != end) {
  if (*p != 'e' && *p != 'E')
    return createError("Invalid character in significand");
  if (p == begin)
    return createError("Significand has no digits");
  if (dot != end && p - begin == 1)
    return createError("Significand has no digits");

  /* p points to the first non-digit in the string */
  auto ExpOrErr = readExponent(p + 1, end);
  if (!ExpOrErr)
    return ExpOrErr.takeError();
  D->exponent = *ExpOrErr;

  /* Implied decimal point?  */
  if (dot == end)
    dot = p;
}

/* If number is all zeroes accept any exponent.  */
if (p != D->firstSigDigit) {
  /* Drop insignificant trailing zeroes.  */
  if (p != begin) {
    do
      do
        p--;
      while (p != begin && *p == '0');
    while (p != begin && *p == '.');
  }

  /* Adjust the exponents for any decimal point.  */
  D->exponent += static_cast<APFloat::ExponentType>((dot - p) - (dot > p));
  D->normalizedExponent = (D->exponent +
            static_cast<APFloat::ExponentType>((p - D->firstSigDigit)
                                    - (dot > D->firstSigDigit && dot < p)));
}

D->lastSigDigit = p;
return Error::success();
572}

574/* Return the trailing fraction of a hexadecimal number.
 DIGITVALUE is the first hex digit of the fraction, P points to
 the next digit.  */
577static Expected<lostFraction>
578trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
                          unsigned int digitValue) {
unsigned int hexDigit;

/* If the first trailing digit isn't 0 or 8 we can work out the
   fraction immediately.  */
if (digitValue > 8)
  return lfMoreThanHalf;
else if (digitValue < 8 && digitValue > 0)
  return lfLessThanHalf;

// Otherwise we need to find the first non-zero digit.
while (p != end && (*p == '0' || *p == '.'))
  p++;

if (p == end)
  return createError("Invalid trailing hexadecimal fraction!");

hexDigit = hexDigitValue(*p);

/* If we ran off the end it is exactly zero or one-half, otherwise
   a little more.  */
if (hexDigit == UINT_MAX(2147483647 *2U +1U))
  return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
else
  return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
604}

606/* Return the fraction lost were a bignum truncated losing the least
 significant BITS bits.  */
608static lostFraction
609lostFractionThroughTruncation(const APFloatBase::integerPart *parts,
                            unsigned int partCount,
                            unsigned int bits)
612{
unsigned int lsb;

lsb = APInt::tcLSB(parts, partCount);

/* Note this is guaranteed true if bits == 0, or LSB == UINT_MAX.  */
if (bits <= lsb)
  return lfExactlyZero;
if (bits == lsb + 1)
  return lfExactlyHalf;
if (bits <= partCount * APFloatBase::integerPartWidth &&
    APInt::tcExtractBit(parts, bits - 1))
  return lfMoreThanHalf;

return lfLessThanHalf;
627}

629/* Shift DST right BITS bits noting lost fraction.  */
630static lostFraction
631shiftRight(APFloatBase::integerPart *dst, unsigned int parts, unsigned int bits)
632{
lostFraction lost_fraction;

lost_fraction = lostFractionThroughTruncation(dst, parts, bits);

APInt::tcShiftRight(dst, parts, bits);

return lost_fraction;
640}

642/* Combine the effect of two lost fractions.  */
643static lostFraction
644combineLostFractions(lostFraction moreSignificant,
                   lostFraction lessSignificant)
646{
if (lessSignificant != lfExactlyZero) {
  if (moreSignificant == lfExactlyZero)
    moreSignificant = lfLessThanHalf;
  else if (moreSignificant == lfExactlyHalf)
    moreSignificant = lfMoreThanHalf;
}

return moreSignificant;
655}

657/* The error from the true value, in half-ulps, on multiplying two
 floating point numbers, which differ from the value they
 approximate by at most HUE1 and HUE2 half-ulps, is strictly less
 than the returned value.

 See "How to Read Floating Point Numbers Accurately" by William D
 Clinger.  */
664static unsigned int
665HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
666{
assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8))(static_cast <bool> (HUerr1 < 2 || HUerr2 < 2 || (
HUerr1 + HUerr2 < 8)) ? void (0) : __assert_fail ("HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8)"
, "llvm/lib/Support/APFloat.cpp", 667, __extension__ __PRETTY_FUNCTION__
));

if (HUerr1 + HUerr2 == 0)
  return inexactMultiply * 2;  /* <= inexactMultiply half-ulps.  */
else
  return inexactMultiply + 2 * (HUerr1 + HUerr2);
673}

675/* The number of ulps from the boundary (zero, or half if ISNEAREST)
 when the least significant BITS are truncated.  BITS cannot be
 zero.  */
678static APFloatBase::integerPart
679ulpsFromBoundary(const APFloatBase::integerPart *parts, unsigned int bits,
               bool isNearest) {
unsigned int count, partBits;
APFloatBase::integerPart part, boundary;

assert(bits != 0)(static_cast <bool> (bits != 0) ? void (0) : __assert_fail
 ("bits != 0", "llvm/lib/Support/APFloat.cpp", 684, __extension__
 __PRETTY_FUNCTION__));

bits--;
count = bits / APFloatBase::integerPartWidth;
partBits = bits % APFloatBase::integerPartWidth + 1;

part = parts[count] & (~(APFloatBase::integerPart) 0 >> (APFloatBase::integerPartWidth - partBits));

if (isNearest)
  boundary = (APFloatBase::integerPart) 1 << (partBits - 1);
else
  boundary = 0;

if (count == 0) {
  if (part - boundary <= boundary - part)
    return part - boundary;
  else
    return boundary - part;
}

if (part == boundary) {
  while (--count)
    if (parts[count])
      return ~(APFloatBase::integerPart) 0; /* A lot.  */

  return parts[0];
} else if (part == boundary - 1) {
  while (--count)
    if (~parts[count])
      return ~(APFloatBase::integerPart) 0; /* A lot.  */

  return -parts[0];
}

return ~(APFloatBase::integerPart) 0; /* A lot.  */
719}

721/* Place pow(5, power) in DST, and return the number of parts used.
 DST must be at least one part larger than size of the answer.  */
723static unsigned int
724powerOf5(APFloatBase::integerPart *dst, unsigned int power) {
static const APFloatBase::integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125, 15625, 78125 };
APFloatBase::integerPart pow5s[maxPowerOfFiveParts * 2 + 5];
pow5s[0] = 78125 * 5;

unsigned int partsCount[16] = { 1 };
APFloatBase::integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
unsigned int result;
assert(power <= maxExponent)(static_cast <bool> (power <= maxExponent) ? void (0
) : __assert_fail ("power <= maxExponent", "llvm/lib/Support/APFloat.cpp"
, 732, __extension__ __PRETTY_FUNCTION__));

p1 = dst;
p2 = scratch;

*p1 = firstEightPowers[power & 7];
power >>= 3;

result = 1;
pow5 = pow5s;

for (unsigned int n = 0; power; power >>= 1, n++) {
  unsigned int pc;

  pc = partsCount[n];

  /* Calculate pow(5,pow(2,n+3)) if we haven't yet.  */
  if (pc == 0) {
    pc = partsCount[n - 1];
    APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
    pc *= 2;
    if (pow5[pc - 1] == 0)
      pc--;
    partsCount[n] = pc;
  }

  if (power & 1) {
    APFloatBase::integerPart *tmp;

    APInt::tcFullMultiply(p2, p1, pow5, result, pc);
    result += pc;
    if (p2[result - 1] == 0)
      result--;

    /* Now result is in p1 with partsCount parts and p2 is scratch
       space.  */
    tmp = p1;
    p1 = p2;
    p2 = tmp;
  }

  pow5 += pc;
}

if (p1 != dst)
  APInt::tcAssign(dst, p1, result);

return result;
780}

782/* Zero at the end to avoid modular arithmetic when adding one; used
 when rounding up during hexadecimal output.  */
784static const char hexDigitsLower[] = "0123456789abcdef0";
785static const char hexDigitsUpper[] = "0123456789ABCDEF0";
786static const char infinityL[] = "infinity";
787static const char infinityU[] = "INFINITY";
788static const char NaNL[] = "nan";
789static const char NaNU[] = "NAN";

791/* Write out an integerPart in hexadecimal, starting with the most
 significant nibble.  Write out exactly COUNT hexdigits, return
 COUNT.  */
794static unsigned int
795partAsHex (char *dst, APFloatBase::integerPart part, unsigned int count,
         const char *hexDigitChars)
797{
unsigned int result = count;

assert(count != 0 && count <= APFloatBase::integerPartWidth / 4)(static_cast <bool> (count != 0 && count <= APFloatBase
::integerPartWidth / 4) ? void (0) : __assert_fail ("count != 0 && count <= APFloatBase::integerPartWidth / 4"
, "llvm/lib/Support/APFloat.cpp", 800, __extension__ __PRETTY_FUNCTION__
));

part >>= (APFloatBase::integerPartWidth - 4 * count);
while (count--) {
  dst[count] = hexDigitChars[part & 0xf];
  part >>= 4;
}

return result;
809}

811/* Write out an unsigned decimal integer.  */
812static char *
813writeUnsignedDecimal (char *dst, unsigned int n)
814{
char buff[40], *p;

p = buff;
do
  *p++ = '0' + n % 10;
while (n /= 10);

do
  *dst++ = *--p;
while (p != buff);

return dst;
827}

829/* Write out a signed decimal integer.  */
830static char *
831writeSignedDecimal (char *dst, int value)
832{
if (value < 0) {
  *dst++ = '-';
  dst = writeUnsignedDecimal(dst, -(unsigned) value);
} else
  dst = writeUnsignedDecimal(dst, value);

return dst;
840}

842namespace detail {
843/* Constructors.  */
844void IEEEFloat::initialize(const fltSemantics *ourSemantics) {
unsigned int count;

semantics = ourSemantics;
count = partCount();
if (count > 1)
  significand.parts = new integerPart[count];
851}

853void IEEEFloat::freeSignificand() {
if (needsCleanup())
  delete [] significand.parts;
856}

858void IEEEFloat::assign(const IEEEFloat &rhs) {
assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 859, __extension__ __PRETTY_FUNCTION__));

sign = rhs.sign;
category = rhs.category;
exponent = rhs.exponent;
if (isFiniteNonZero() || category == fcNaN)
  copySignificand(rhs);
866}

868void IEEEFloat::copySignificand(const IEEEFloat &rhs) {
assert(isFiniteNonZero() || category == fcNaN)(static_cast <bool> (isFiniteNonZero() || category == fcNaN
) ? void (0) : __assert_fail ("isFiniteNonZero() || category == fcNaN"
, "llvm/lib/Support/APFloat.cpp", 869, __extension__ __PRETTY_FUNCTION__
));
assert(rhs.partCount() >= partCount())(static_cast <bool> (rhs.partCount() >= partCount())
 ? void (0) : __assert_fail ("rhs.partCount() >= partCount()"
, "llvm/lib/Support/APFloat.cpp", 870, __extension__ __PRETTY_FUNCTION__
));

APInt::tcAssign(significandParts(), rhs.significandParts(),
                partCount());
874}

876/* Make this number a NaN, with an arbitrary but deterministic value
 for the significand.  If double or longer, this is a signalling NaN,
 which may not be ideal.  If float, this is QNaN(0).  */
879void IEEEFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill) {
category = fcNaN;
sign = Negative;
exponent = exponentNaN();

integerPart *significand = significandParts();
unsigned numParts = partCount();

APInt fill_storage;
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
  // Finite-only types do not distinguish signalling and quiet NaN, so
  // make them all signalling.
  SNaN = false;
  if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
    sign = true;
    fill_storage = APInt::getZero(semantics->precision - 1);
  } else {
    fill_storage = APInt::getAllOnes(semantics->precision - 1);
  }
  fill = &fill_storage;
}

// Set the significand bits to the fill.
if (!fill || fill->getNumWords() < numParts)
  APInt::tcSet(significand, 0, numParts);
if (fill) {
  APInt::tcAssign(significand, fill->getRawData(),
                  std::min(fill->getNumWords(), numParts));

  // Zero out the excess bits of the significand.
  unsigned bitsToPreserve = semantics->precision - 1;
  unsigned part = bitsToPreserve / 64;
  bitsToPreserve %= 64;
  significand[part] &= ((1ULL << bitsToPreserve) - 1);
  for (part++; part != numParts; ++part)
    significand[part] = 0;
}

unsigned QNaNBit = semantics->precision - 2;

if (SNaN) {
  // We always have to clear the QNaN bit to make it an SNaN.
  APInt::tcClearBit(significand, QNaNBit);

  // If there are no bits set in the payload, we have to set
  // *something* to make it a NaN instead of an infinity;
  // conventionally, this is the next bit down from the QNaN bit.
  if (APInt::tcIsZero(significand, numParts))
    APInt::tcSetBit(significand, QNaNBit - 1);
} else if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
  // The only NaN is a quiet NaN, and it has no bits sets in the significand.
  // Do nothing.
} else {
  // We always have to set the QNaN bit to make it a QNaN.
  APInt::tcSetBit(significand, QNaNBit);
}

// For x87 extended precision, we want to make a NaN, not a
// pseudo-NaN.  Maybe we should expose the ability to make
// pseudo-NaNs?
if (semantics == &semX87DoubleExtended)
  APInt::tcSetBit(significand, QNaNBit + 1);
941}

943IEEEFloat &IEEEFloat::operator=(const IEEEFloat &rhs) {
if (this != &rhs) {
  if (semantics != rhs.semantics) {
    freeSignificand();
    initialize(rhs.semantics);
  }
  assign(rhs);
}

return *this;
953}

955IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
freeSignificand();

semantics = rhs.semantics;
significand = rhs.significand;
exponent = rhs.exponent;
category = rhs.category;
sign = rhs.sign;

rhs.semantics = &semBogus;
return *this;
966}

968bool IEEEFloat::isDenormal() const {
return isFiniteNonZero() && (exponent == semantics->minExponent) &&
       (APInt::tcExtractBit(significandParts(),
                            semantics->precision - 1) == 0);
972}

974bool IEEEFloat::isSmallest() const {
// The smallest number by magnitude in our format will be the smallest
// denormal, i.e. the floating point number with exponent being minimum
// exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
return isFiniteNonZero() && exponent == semantics->minExponent &&
  significandMSB() == 0;
980}

982bool IEEEFloat::isSmallestNormalized() const {
return getCategory() == fcNormal && exponent == semantics->minExponent &&
       isSignificandAllZerosExceptMSB();
985}

987bool IEEEFloat::isSignificandAllOnes() const {
// Test if the significand excluding the integral bit is all ones. This allows
// us to test for binade boundaries.
const integerPart *Parts = significandParts();
const unsigned PartCount = partCountForBits(semantics->precision);
for (unsigned i = 0; i < PartCount - 1; i++)
  if (~Parts[i])
    return false;

// Set the unused high bits to all ones when we compare.
const unsigned NumHighBits =
  PartCount*integerPartWidth - semantics->precision + 1;
assert(NumHighBits <= integerPartWidth && NumHighBits > 0 &&(static_cast <bool> (NumHighBits <= integerPartWidth
 && NumHighBits > 0 && "Can not have more high bits to fill than integerPartWidth"
) ? void (0) : __assert_fail ("NumHighBits <= integerPartWidth && NumHighBits > 0 && \"Can not have more high bits to fill than integerPartWidth\""
, "llvm/lib/Support/APFloat.cpp", 1000, __extension__ __PRETTY_FUNCTION__
))
       "Can not have more high bits to fill than integerPartWidth")(static_cast <bool> (NumHighBits <= integerPartWidth
 && NumHighBits > 0 && "Can not have more high bits to fill than integerPartWidth"
) ? void (0) : __assert_fail ("NumHighBits <= integerPartWidth && NumHighBits > 0 && \"Can not have more high bits to fill than integerPartWidth\""
, "llvm/lib/Support/APFloat.cpp", 1000, __extension__ __PRETTY_FUNCTION__
));
const integerPart HighBitFill =
  ~integerPart(0) << (integerPartWidth - NumHighBits);
if (~(Parts[PartCount - 1] | HighBitFill))
  return false;

return true;
1007}

1009bool IEEEFloat::isSignificandAllOnesExceptLSB() const {
// Test if the significand excluding the integral bit is all ones except for
// the least significant bit.
const integerPart *Parts = significandParts();

if (Parts[0] & 1)
  return false;

const unsigned PartCount = partCountForBits(semantics->precision);
for (unsigned i = 0; i < PartCount - 1; i++) {
  if (~Parts[i] & ~unsigned{!i})
    return false;
}

// Set the unused high bits to all ones when we compare.
const unsigned NumHighBits =
    PartCount * integerPartWidth - semantics->precision + 1;
assert(NumHighBits <= integerPartWidth && NumHighBits > 0 &&(static_cast <bool> (NumHighBits <= integerPartWidth
 && NumHighBits > 0 && "Can not have more high bits to fill than integerPartWidth"
) ? void (0) : __assert_fail ("NumHighBits <= integerPartWidth && NumHighBits > 0 && \"Can not have more high bits to fill than integerPartWidth\""
, "llvm/lib/Support/APFloat.cpp", 1027, __extension__ __PRETTY_FUNCTION__
))
       "Can not have more high bits to fill than integerPartWidth")(static_cast <bool> (NumHighBits <= integerPartWidth
 && NumHighBits > 0 && "Can not have more high bits to fill than integerPartWidth"
) ? void (0) : __assert_fail ("NumHighBits <= integerPartWidth && NumHighBits > 0 && \"Can not have more high bits to fill than integerPartWidth\""
, "llvm/lib/Support/APFloat.cpp", 1027, __extension__ __PRETTY_FUNCTION__
));
const integerPart HighBitFill = ~integerPart(0)
                                << (integerPartWidth - NumHighBits);
if (~(Parts[PartCount - 1] | HighBitFill | 0x1))
  return false;

return true;
1034}

1036bool IEEEFloat::isSignificandAllZeros() const {
// Test if the significand excluding the integral bit is all zeros. This
// allows us to test for binade boundaries.
const integerPart *Parts = significandParts();
const unsigned PartCount = partCountForBits(semantics->precision);

for (unsigned i = 0; i < PartCount - 1; i++)
  if (Parts[i])
    return false;

// Compute how many bits are used in the final word.
const unsigned NumHighBits =
  PartCount*integerPartWidth - semantics->precision + 1;
assert(NumHighBits < integerPartWidth && "Can not have more high bits to "(static_cast <bool> (NumHighBits < integerPartWidth &&
 "Can not have more high bits to " "clear than integerPartWidth"
) ? void (0) : __assert_fail ("NumHighBits < integerPartWidth && \"Can not have more high bits to \" \"clear than integerPartWidth\""
, "llvm/lib/Support/APFloat.cpp", 1050, __extension__ __PRETTY_FUNCTION__
))
       "clear than integerPartWidth")(static_cast <bool> (NumHighBits < integerPartWidth &&
 "Can not have more high bits to " "clear than integerPartWidth"
) ? void (0) : __assert_fail ("NumHighBits < integerPartWidth && \"Can not have more high bits to \" \"clear than integerPartWidth\""
, "llvm/lib/Support/APFloat.cpp", 1050, __extension__ __PRETTY_FUNCTION__
));
const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;

if (Parts[PartCount - 1] & HighBitMask)
  return false;

return true;
1057}

1059bool IEEEFloat::isSignificandAllZerosExceptMSB() const {
const integerPart *Parts = significandParts();
const unsigned PartCount = partCountForBits(semantics->precision);

for (unsigned i = 0; i < PartCount - 1; i++) {
  if (Parts[i])
    return false;
}

const unsigned NumHighBits =
    PartCount * integerPartWidth - semantics->precision + 1;
return Parts[PartCount - 1] == integerPart(1)
                                   << (integerPartWidth - NumHighBits);
1072}

1074bool IEEEFloat::isLargest() const {
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
    semantics->nanEncoding == fltNanEncoding::AllOnes) {
  // The largest number by magnitude in our format will be the floating point
  // number with maximum exponent and with significand that is all ones except
  // the LSB.
  return isFiniteNonZero() && exponent == semantics->maxExponent &&
         isSignificandAllOnesExceptLSB();
} else {
  // The largest number by magnitude in our format will be the floating point
  // number with maximum exponent and with significand that is all ones.
  return isFiniteNonZero() && exponent == semantics->maxExponent &&
         isSignificandAllOnes();
}
1088}

1090bool IEEEFloat::isInteger() const {
// This could be made more efficient; I'm going for obviously correct.
if (!isFinite()) return false;
IEEEFloat truncated = *this;
truncated.roundToIntegral(rmTowardZero);
return compare(truncated) == cmpEqual;
1096}

1098bool IEEEFloat::bitwiseIsEqual(const IEEEFloat &rhs) const {
if (this == &rhs)
  return true;
if (semantics != rhs.semantics ||
    category != rhs.category ||
    sign != rhs.sign)
  return false;
if (category==fcZero || category==fcInfinity)
  return true;

if (isFiniteNonZero() && exponent != rhs.exponent)
  return false;

return std::equal(significandParts(), significandParts() + partCount(),
                  rhs.significandParts());
1113}

1115IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, integerPart value) {
initialize(&ourSemantics);
sign = 0;
category = fcNormal;
zeroSignificand();
exponent = ourSemantics.precision - 1;
significandParts()[0] = value;
normalize(rmNearestTiesToEven, lfExactlyZero);
1123}

1125IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics) {
initialize(&ourSemantics);
makeZero(false);
1128}

1130// Delegate to the previous constructor, because later copy constructor may
1131// actually inspects category, which can't be garbage.
1132IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, uninitializedTag tag)
  : IEEEFloat(ourSemantics) {}

1135IEEEFloat::IEEEFloat(const IEEEFloat &rhs) {
initialize(rhs.semantics);
assign(rhs);
1138}

1140IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&semBogus) {
*this = std::move(rhs);
1142}

1144IEEEFloat::~IEEEFloat() { freeSignificand(); }

1146unsigned int IEEEFloat::partCount() const {
return partCountForBits(semantics->precision + 1);
1148}

1150const IEEEFloat::integerPart *IEEEFloat::significandParts() const {
return const_cast<IEEEFloat *>(this)->significandParts();
1152}

1154IEEEFloat::integerPart *IEEEFloat::significandParts() {
if (partCount() > 1)
  return significand.parts;
else
  return &significand.part;
1159}

1161void IEEEFloat::zeroSignificand() {
APInt::tcSet(significandParts(), 0, partCount());
1163}

1165/* Increment an fcNormal floating point number's significand.  */
1166void IEEEFloat::incrementSignificand() {
integerPart carry;

carry = APInt::tcIncrement(significandParts(), partCount());

/* Our callers should never cause us to overflow.  */
assert(carry == 0)(static_cast <bool> (carry == 0) ? void (0) : __assert_fail
 ("carry == 0", "llvm/lib/Support/APFloat.cpp", 1172, __extension__
 __PRETTY_FUNCTION__));
(void)carry;
1174}

1176/* Add the significand of the RHS.  Returns the carry flag.  */
1177IEEEFloat::integerPart IEEEFloat::addSignificand(const IEEEFloat &rhs) {
integerPart *parts;

parts = significandParts();

assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 1182, __extension__ __PRETTY_FUNCTION__));
assert(exponent == rhs.exponent)(static_cast <bool> (exponent == rhs.exponent) ? void (
0) : __assert_fail ("exponent == rhs.exponent", "llvm/lib/Support/APFloat.cpp"
, 1183, __extension__ __PRETTY_FUNCTION__));

return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
1186}

1188/* Subtract the significand of the RHS with a borrow flag.  Returns
 the borrow flag.  */
1190IEEEFloat::integerPart IEEEFloat::subtractSignificand(const IEEEFloat &rhs,
                                                    integerPart borrow) {
integerPart *parts;

parts = significandParts();

assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 1196, __extension__ __PRETTY_FUNCTION__));
assert(exponent == rhs.exponent)(static_cast <bool> (exponent == rhs.exponent) ? void (
0) : __assert_fail ("exponent == rhs.exponent", "llvm/lib/Support/APFloat.cpp"
, 1197, __extension__ __PRETTY_FUNCTION__));

return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
                         partCount());
1201}

1203/* Multiply the significand of the RHS.  If ADDEND is non-NULL, add it
 on to the full-precision result of the multiplication.  Returns the
 lost fraction.  */
1206lostFraction IEEEFloat::multiplySignificand(const IEEEFloat &rhs,
                                          IEEEFloat addend) {
unsigned int omsb;        // One, not zero, based MSB.
unsigned int partsCount, newPartsCount, precision;
integerPart *lhsSignificand;
integerPart scratch[4];
integerPart *fullSignificand;
lostFraction lost_fraction;
bool ignored;

assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 1216, __extension__ __PRETTY_FUNCTION__));

precision = semantics->precision;

// Allocate space for twice as many bits as the original significand, plus one
// extra bit for the addition to overflow into.
newPartsCount = partCountForBits(precision * 2 + 1);

if (newPartsCount > 4)
  fullSignificand = new integerPart[newPartsCount];
else
  fullSignificand = scratch;

lhsSignificand = significandParts();
partsCount = partCount();

APInt::tcFullMultiply(fullSignificand, lhsSignificand,
                      rhs.significandParts(), partsCount, partsCount);

lost_fraction = lfExactlyZero;
omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
exponent += rhs.exponent;

// Assume the operands involved in the multiplication are single-precision
// FP, and the two multiplicants are:
//   *this = a23 . a22 ... a0 * 2^e1
//     rhs = b23 . b22 ... b0 * 2^e2
// the result of multiplication is:
//   *this = c48 c47 c46 . c45 ... c0 * 2^(e1+e2)
// Note that there are three significant bits at the left-hand side of the
// radix point: two for the multiplication, and an overflow bit for the
// addition (that will always be zero at this point). Move the radix point
// toward left by two bits, and adjust exponent accordingly.
exponent += 2;

if (addend.isNonZero()) {
  // The intermediate result of the multiplication has "2 * precision"
  // signicant bit; adjust the addend to be consistent with mul result.
  //
  Significand savedSignificand = significand;
  const fltSemantics *savedSemantics = semantics;
  fltSemantics extendedSemantics;
  opStatus status;
  unsigned int extendedPrecision;

  // Normalize our MSB to one below the top bit to allow for overflow.
  extendedPrecision = 2 * precision + 1;
  if (omsb != extendedPrecision - 1) {
    assert(extendedPrecision > omsb)(static_cast <bool> (extendedPrecision > omsb) ? void
 (0) : __assert_fail ("extendedPrecision > omsb", "llvm/lib/Support/APFloat.cpp"
, 1264, __extension__ __PRETTY_FUNCTION__));
    APInt::tcShiftLeft(fullSignificand, newPartsCount,
                       (extendedPrecision - 1) - omsb);
    exponent -= (extendedPrecision - 1) - omsb;
  }

  /* Create new semantics.  */
  extendedSemantics = *semantics;
  extendedSemantics.precision = extendedPrecision;

  if (newPartsCount == 1)
    significand.part = fullSignificand[0];
  else
    significand.parts = fullSignificand;
  semantics = &extendedSemantics;

  // Make a copy so we can convert it to the extended semantics.
  // Note that we cannot convert the addend directly, as the extendedSemantics
  // is a local variable (which we take a reference to).
  IEEEFloat extendedAddend(addend);
  status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
  assert(status == opOK)(static_cast <bool> (status == opOK) ? void (0) : __assert_fail
 ("status == opOK", "llvm/lib/Support/APFloat.cpp", 1285, __extension__
 __PRETTY_FUNCTION__));
  (void)status;

  // Shift the significand of the addend right by one bit. This guarantees
  // that the high bit of the significand is zero (same as fullSignificand),
  // so the addition will overflow (if it does overflow at all) into the top bit.
  lost_fraction = extendedAddend.shiftSignificandRight(1);
  assert(lost_fraction == lfExactlyZero &&(static_cast <bool> (lost_fraction == lfExactlyZero &&
 "Lost precision while shifting addend for fused-multiply-add."
) ? void (0) : __assert_fail ("lost_fraction == lfExactlyZero && \"Lost precision while shifting addend for fused-multiply-add.\""
, "llvm/lib/Support/APFloat.cpp", 1293, __extension__ __PRETTY_FUNCTION__
))
         "Lost precision while shifting addend for fused-multiply-add.")(static_cast <bool> (lost_fraction == lfExactlyZero &&
 "Lost precision while shifting addend for fused-multiply-add."
) ? void (0) : __assert_fail ("lost_fraction == lfExactlyZero && \"Lost precision while shifting addend for fused-multiply-add.\""
, "llvm/lib/Support/APFloat.cpp", 1293, __extension__ __PRETTY_FUNCTION__
));

  lost_fraction = addOrSubtractSignificand(extendedAddend, false);

  /* Restore our state.  */
  if (newPartsCount == 1)
    fullSignificand[0] = significand.part;
  significand = savedSignificand;
  semantics = savedSemantics;

  omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
}

// Convert the result having "2 * precision" significant-bits back to the one
// having "precision" significant-bits. First, move the radix point from
// poision "2*precision - 1" to "precision - 1". The exponent need to be
// adjusted by "2*precision - 1" - "precision - 1" = "precision".
exponent -= precision + 1;

// In case MSB resides at the left-hand side of radix point, shift the
// mantissa right by some amount to make sure the MSB reside right before
// the radix point (i.e. "MSB . rest-significant-bits").
//
// Note that the result is not normalized when "omsb < precision". So, the
// caller needs to call IEEEFloat::normalize() if normalized value is
// expected.
if (omsb > precision) {
  unsigned int bits, significantParts;
  lostFraction lf;

  bits = omsb - precision;
  significantParts = partCountForBits(omsb);
  lf = shiftRight(fullSignificand, significantParts, bits);
  lost_fraction = combineLostFractions(lf, lost_fraction);
  exponent += bits;
}

APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);

if (newPartsCount > 4)
  delete [] fullSignificand;

return lost_fraction;
1336}

1338lostFraction IEEEFloat::multiplySignificand(const IEEEFloat &rhs) {
return multiplySignificand(rhs, IEEEFloat(*semantics));
1340}

1342/* Multiply the significands of LHS and RHS to DST.  */
1343lostFraction IEEEFloat::divideSignificand(const IEEEFloat &rhs) {
unsigned int bit, i, partsCount;
const integerPart *rhsSignificand;
integerPart *lhsSignificand, *dividend, *divisor;
integerPart scratch[4];
lostFraction lost_fraction;

assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 1350, __extension__ __PRETTY_FUNCTION__));

lhsSignificand = significandParts();
rhsSignificand = rhs.significandParts();
partsCount = partCount();

if (partsCount > 2)
  dividend = new integerPart[partsCount * 2];
else
  dividend = scratch;

divisor = dividend + partsCount;

/* Copy the dividend and divisor as they will be modified in-place.  */
for (i = 0; i < partsCount; i++) {
  dividend[i] = lhsSignificand[i];
  divisor[i] = rhsSignificand[i];
  lhsSignificand[i] = 0;
}

exponent -= rhs.exponent;

unsigned int precision = semantics->precision;

/* Normalize the divisor.  */
bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
if (bit) {
  exponent += bit;
  APInt::tcShiftLeft(divisor, partsCount, bit);
}

/* Normalize the dividend.  */
bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
if (bit) {
  exponent -= bit;
  APInt::tcShiftLeft(dividend, partsCount, bit);
}

/* Ensure the dividend >= divisor initially for the loop below.
   Incidentally, this means that the division loop below is
   guaranteed to set the integer bit to one.  */
if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
  exponent--;
  APInt::tcShiftLeft(dividend, partsCount, 1);
  assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0)(static_cast <bool> (APInt::tcCompare(dividend, divisor
, partsCount) >= 0) ? void (0) : __assert_fail ("APInt::tcCompare(dividend, divisor, partsCount) >= 0"
, "llvm/lib/Support/APFloat.cpp", 1394, __extension__ __PRETTY_FUNCTION__
));
}

/* Long division.  */
for (bit = precision; bit; bit -= 1) {
  if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
    APInt::tcSubtract(dividend, divisor, 0, partsCount);
    APInt::tcSetBit(lhsSignificand, bit - 1);
  }

  APInt::tcShiftLeft(dividend, partsCount, 1);
}

/* Figure out the lost fraction.  */
int cmp = APInt::tcCompare(dividend, divisor, partsCount);

if (cmp > 0)
  lost_fraction = lfMoreThanHalf;
else if (cmp == 0)
  lost_fraction = lfExactlyHalf;
else if (APInt::tcIsZero(dividend, partsCount))
  lost_fraction = lfExactlyZero;
else
  lost_fraction = lfLessThanHalf;

if (partsCount > 2)
  delete [] dividend;

return lost_fraction;
1423}

1425unsigned int IEEEFloat::significandMSB() const {
return APInt::tcMSB(significandParts(), partCount());
1427}

1429unsigned int IEEEFloat::significandLSB() const {
return APInt::tcLSB(significandParts(), partCount());
1431}

1433/* Note that a zero result is NOT normalized to fcZero.  */
1434lostFraction IEEEFloat::shiftSignificandRight(unsigned int bits) {
/* Our exponent should not overflow.  */
assert((ExponentType) (exponent + bits) >= exponent)(static_cast <bool> ((ExponentType) (exponent + bits) >=
 exponent) ? void (0) : __assert_fail ("(ExponentType) (exponent + bits) >= exponent"
, "llvm/lib/Support/APFloat.cpp", 1436, __extension__ __PRETTY_FUNCTION__
));

exponent += bits;

return shiftRight(significandParts(), partCount(), bits);
1441}

1443/* Shift the significand left BITS bits, subtract BITS from its exponent.  */
1444void IEEEFloat::shiftSignificandLeft(unsigned int bits) {
assert(bits < semantics->precision)(static_cast <bool> (bits < semantics->precision)
 ? void (0) : __assert_fail ("bits < semantics->precision"
, "llvm/lib/Support/APFloat.cpp", 1445, __extension__ __PRETTY_FUNCTION__
));

if (bits) {
  unsigned int partsCount = partCount();

  APInt::tcShiftLeft(significandParts(), partsCount, bits);
  exponent -= bits;

  assert(!APInt::tcIsZero(significandParts(), partsCount))(static_cast <bool> (!APInt::tcIsZero(significandParts(
), partsCount)) ? void (0) : __assert_fail ("!APInt::tcIsZero(significandParts(), partsCount)"
, "llvm/lib/Support/APFloat.cpp", 1453, __extension__ __PRETTY_FUNCTION__
));
}
1455}

1457IEEEFloat::cmpResult
1458IEEEFloat::compareAbsoluteValue(const IEEEFloat &rhs) const {
int compare;

assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 1461, __extension__ __PRETTY_FUNCTION__));
assert(isFiniteNonZero())(static_cast <bool> (isFiniteNonZero()) ? void (0) : __assert_fail
 ("isFiniteNonZero()", "llvm/lib/Support/APFloat.cpp", 1462, __extension__
 __PRETTY_FUNCTION__));
assert(rhs.isFiniteNonZero())(static_cast <bool> (rhs.isFiniteNonZero()) ? void (0) :
 __assert_fail ("rhs.isFiniteNonZero()", "llvm/lib/Support/APFloat.cpp"
, 1463, __extension__ __PRETTY_FUNCTION__));

compare = exponent - rhs.exponent;

/* If exponents are equal, do an unsigned bignum comparison of the
   significands.  */
if (compare == 0)
  compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
                             partCount());

if (compare > 0)
  return cmpGreaterThan;
else if (compare < 0)
  return cmpLessThan;
else
  return cmpEqual;
1479}

1481/* Set the least significant BITS bits of a bignum, clear the
 rest.  */
1483static void tcSetLeastSignificantBits(APInt::WordType *dst, unsigned parts,
                                    unsigned bits) {
unsigned i = 0;
while (bits > APInt::APINT_BITS_PER_WORD) {
  dst[i++] = ~(APInt::WordType)0;
  bits -= APInt::APINT_BITS_PER_WORD;
}

if (bits)
  dst[i++] = ~(APInt::WordType)0 >> (APInt::APINT_BITS_PER_WORD - bits);

while (i < parts)
  dst[i++] = 0;
1496}

1498/* Handle overflow.  Sign is preserved.  We either become infinity or
 the largest finite number.  */
1500IEEEFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) {
/* Infinity?  */
if (rounding_mode == rmNearestTiesToEven ||
    rounding_mode == rmNearestTiesToAway ||
    (rounding_mode == rmTowardPositive && !sign) ||
    (rounding_mode == rmTowardNegative && sign)) {
  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
    makeNaN(false, sign);
  else
    category = fcInfinity;
  return (opStatus) (opOverflow | opInexact);
}

/* Otherwise we become the largest finite number.  */
category = fcNormal;
exponent = semantics->maxExponent;
tcSetLeastSignificantBits(significandParts(), partCount(),
                          semantics->precision);
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
    semantics->nanEncoding == fltNanEncoding::AllOnes)
  APInt::tcClearBit(significandParts(), 0);

return opInexact;
1523}

1525/* Returns TRUE if, when truncating the current number, with BIT the
 new LSB, with the given lost fraction and rounding mode, the result
 would need to be rounded away from zero (i.e., by increasing the
 signficand).  This routine must work for fcZero of both signs, and
 fcNormal numbers.  */
1530bool IEEEFloat::roundAwayFromZero(roundingMode rounding_mode,
                                lostFraction lost_fraction,
                                unsigned int bit) const {
/* NaNs and infinities should not have lost fractions.  */
assert(isFiniteNonZero() || category == fcZero)(static_cast <bool> (isFiniteNonZero() || category == fcZero
) ? void (0) : __assert_fail ("isFiniteNonZero() || category == fcZero"
, "llvm/lib/Support/APFloat.cpp", 1534, __extension__ __PRETTY_FUNCTION__
));

/* Current callers never pass this so we don't handle it.  */
assert(lost_fraction != lfExactlyZero)(static_cast <bool> (lost_fraction != lfExactlyZero) ? void
 (0) : __assert_fail ("lost_fraction != lfExactlyZero", "llvm/lib/Support/APFloat.cpp"
, 1537, __extension__ __PRETTY_FUNCTION__));

switch (rounding_mode) {
case rmNearestTiesToAway:
  return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;

case rmNearestTiesToEven:
  if (lost_fraction == lfMoreThanHalf)
    return true;

  /* Our zeroes don't have a significand to test.  */
  if (lost_fraction == lfExactlyHalf && category != fcZero)
    return APInt::tcExtractBit(significandParts(), bit);

  return false;

case rmTowardZero:
  return false;

case rmTowardPositive:
  return !sign;

case rmTowardNegative:
  return sign;

default:
  break;
}
llvm_unreachable("Invalid rounding mode found")::llvm::llvm_unreachable_internal("Invalid rounding mode found"
, "llvm/lib/Support/APFloat.cpp", 1565);
1566}

1568IEEEFloat::opStatus IEEEFloat::normalize(roundingMode rounding_mode,
                                       lostFraction lost_fraction) {
unsigned int omsb;                /* One, not zero, based MSB.  */
int exponentChange;

if (!isFiniteNonZero())
  return opOK;

/* Before rounding normalize the exponent of fcNormal numbers.  */
omsb = significandMSB() + 1;

if (omsb) {
  /* OMSB is numbered from 1.  We want to place it in the integer
     bit numbered PRECISION if possible, with a compensating change in
     the exponent.  */
  exponentChange = omsb - semantics->precision;

  /* If the resulting exponent is too high, overflow according to
     the rounding mode.  */
  if (exponent + exponentChange > semantics->maxExponent)
    return handleOverflow(rounding_mode);

  /* Subnormal numbers have exponent minExponent, and their MSB
     is forced based on that.  */
  if (exponent + exponentChange < semantics->minExponent)
    exponentChange = semantics->minExponent - exponent;

  /* Shifting left is easy as we don't lose precision.  */
  if (exponentChange < 0) {
    assert(lost_fraction == lfExactlyZero)(static_cast <bool> (lost_fraction == lfExactlyZero) ? void
 (0) : __assert_fail ("lost_fraction == lfExactlyZero", "llvm/lib/Support/APFloat.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__));

    shiftSignificandLeft(-exponentChange);

    return opOK;
  }

  if (exponentChange > 0) {
    lostFraction lf;

    /* Shift right and capture any new lost fraction.  */
    lf = shiftSignificandRight(exponentChange);

    lost_fraction = combineLostFractions(lf, lost_fraction);

    /* Keep OMSB up-to-date.  */
    if (omsb > (unsigned) exponentChange)
      omsb -= exponentChange;
    else
      omsb = 0;
  }
}

// The all-ones values is an overflow if NaN is all ones. If NaN is
// represented by negative zero, then it is a valid finite value.
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
    semantics->nanEncoding == fltNanEncoding::AllOnes &&
    exponent == semantics->maxExponent && isSignificandAllOnes())
  return handleOverflow(rounding_mode);

/* Now round the number according to rounding_mode given the lost
   fraction.  */

/* As specified in IEEE 754, since we do not trap we do not report
   underflow for exact results.  */
if (lost_fraction == lfExactlyZero) {
  /* Canonicalize zeroes.  */
  if (omsb == 0) {
    category = fcZero;
    if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
      sign = false;
  }

  return opOK;
}

/* Increment the significand if we're rounding away from zero.  */
if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
  if (omsb == 0)
    exponent = semantics->minExponent;

  incrementSignificand();
  omsb = significandMSB() + 1;

  /* Did the significand increment overflow?  */
  if (omsb == (unsigned) semantics->precision + 1) {
    /* Renormalize by incrementing the exponent and shifting our
       significand right one.  However if we already have the
       maximum exponent we overflow to infinity.  */
    if (exponent == semantics->maxExponent)
      // Invoke overflow handling with a rounding mode that will guarantee
      // that the result gets turned into the correct infinity representation.
      // This is needed instead of just setting the category to infinity to
      // account for 8-bit floating point types that have no inf, only NaN.
      return handleOverflow(sign ? rmTowardNegative : rmTowardPositive);

    shiftSignificandRight(1);

    return opInexact;
  }

  // The all-ones values is an overflow if NaN is all ones. If NaN is
  // represented by negative zero, then it is a valid finite value.
  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
      semantics->nanEncoding == fltNanEncoding::AllOnes &&
      exponent == semantics->maxExponent && isSignificandAllOnes())
    return handleOverflow(rounding_mode);
}

/* The normal case - we were and are not denormal, and any
   significand increment above didn't overflow.  */
if (omsb == semantics->precision)
  return opInexact;

/* We have a non-zero denormal.  */
assert(omsb < semantics->precision)(static_cast <bool> (omsb < semantics->precision)
 ? void (0) : __assert_fail ("omsb < semantics->precision"
, "llvm/lib/Support/APFloat.cpp", 1682, __extension__ __PRETTY_FUNCTION__
));

/* Canonicalize zeroes.  */
if (omsb == 0) {
  category = fcZero;
  if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
    sign = false;
}

/* The fcZero case is a denormal that underflowed to zero.  */
return (opStatus) (opUnderflow | opInexact);
1693}

1695IEEEFloat::opStatus IEEEFloat::addOrSubtractSpecials(const IEEEFloat &rhs,
                                                   bool subtract) {
switch (PackCategoriesIntoKey(category, rhs.category)((category) * 4 + (rhs.category))) {
default:
  llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 1699);

case PackCategoriesIntoKey(fcZero, fcNaN)((fcZero) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcNormal, fcNaN)((fcNormal) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcInfinity, fcNaN)((fcInfinity) * 4 + (fcNaN)):
  assign(rhs);
  [[fallthrough]];
case PackCategoriesIntoKey(fcNaN, fcZero)((fcNaN) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNaN, fcNormal)((fcNaN) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNaN, fcInfinity)((fcNaN) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcNaN, fcNaN)((fcNaN) * 4 + (fcNaN)):
  if (isSignaling()) {
    makeQuiet();
    return opInvalidOp;
  }
  return rhs.isSignaling() ? opInvalidOp : opOK;

case PackCategoriesIntoKey(fcNormal, fcZero)((fcNormal) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcInfinity, fcNormal)((fcInfinity) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcInfinity, fcZero)((fcInfinity) * 4 + (fcZero)):
  return opOK;

case PackCategoriesIntoKey(fcNormal, fcInfinity)((fcNormal) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcInfinity)((fcZero) * 4 + (fcInfinity)):
  category = fcInfinity;
  sign = rhs.sign ^ subtract;
  return opOK;

case PackCategoriesIntoKey(fcZero, fcNormal)((fcZero) * 4 + (fcNormal)):
  assign(rhs);
  sign = rhs.sign ^ subtract;
  return opOK;

case PackCategoriesIntoKey(fcZero, fcZero)((fcZero) * 4 + (fcZero)):
  /* Sign depends on rounding mode; handled by caller.  */
  return opOK;

case PackCategoriesIntoKey(fcInfinity, fcInfinity)((fcInfinity) * 4 + (fcInfinity)):
  /* Differently signed infinities can only be validly
     subtracted.  */
  if (((sign ^ rhs.sign)!=0) != subtract) {
    makeNaN();
    return opInvalidOp;
  }

  return opOK;

case PackCategoriesIntoKey(fcNormal, fcNormal)((fcNormal) * 4 + (fcNormal)):
  return opDivByZero;
}
1749}

1751/* Add or subtract two normal numbers.  */
1752lostFraction IEEEFloat::addOrSubtractSignificand(const IEEEFloat &rhs,
                                               bool subtract) {
integerPart carry;
lostFraction lost_fraction;
int bits;

/* Determine if the operation on the absolute values is effectively
   an addition or subtraction.  */
subtract ^= static_cast<bool>(sign ^ rhs.sign);

/* Are we bigger exponent-wise than the RHS?  */
bits = exponent - rhs.exponent;

/* Subtraction is more subtle than one might naively expect.  */
if (subtract) {
  IEEEFloat temp_rhs(rhs);

  if (bits == 0)
    lost_fraction = lfExactlyZero;
  else if (bits > 0) {
    lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
    shiftSignificandLeft(1);
  } else {
    lost_fraction = shiftSignificandRight(-bits - 1);
    temp_rhs.shiftSignificandLeft(1);
  }

  // Should we reverse the subtraction.
  if (compareAbsoluteValue(temp_rhs) == cmpLessThan) {
    carry = temp_rhs.subtractSignificand
      (*this, lost_fraction != lfExactlyZero);
    copySignificand(temp_rhs);
    sign = !sign;
  } else {
    carry = subtractSignificand
      (temp_rhs, lost_fraction != lfExactlyZero);
  }

  /* Invert the lost fraction - it was on the RHS and
     subtracted.  */
  if (lost_fraction == lfLessThanHalf)
    lost_fraction = lfMoreThanHalf;
  else if (lost_fraction == lfMoreThanHalf)
    lost_fraction = lfLessThanHalf;

  /* The code above is intended to ensure that no borrow is
     necessary.  */
  assert(!carry)(static_cast <bool> (!carry) ? void (0) : __assert_fail
 ("!carry", "llvm/lib/Support/APFloat.cpp", 1799, __extension__
 __PRETTY_FUNCTION__));
  (void)carry;
} else {
  if (bits > 0) {
    IEEEFloat temp_rhs(rhs);

    lost_fraction = temp_rhs.shiftSignificandRight(bits);
    carry = addSignificand(temp_rhs);
  } else {
    lost_fraction = shiftSignificandRight(-bits);
    carry = addSignificand(rhs);
  }

  /* We have a guard bit; generating a carry cannot happen.  */
  assert(!carry)(static_cast <bool> (!carry) ? void (0) : __assert_fail
 ("!carry", "llvm/lib/Support/APFloat.cpp", 1813, __extension__
 __PRETTY_FUNCTION__));
  (void)carry;
}

return lost_fraction;
1818}

1820IEEEFloat::opStatus IEEEFloat::multiplySpecials(const IEEEFloat &rhs) {
switch (PackCategoriesIntoKey(category, rhs.category)((category) * 4 + (rhs.category))) {
default:
  llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 1823);

case PackCategoriesIntoKey(fcZero, fcNaN)((fcZero) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcNormal, fcNaN)((fcNormal) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcInfinity, fcNaN)((fcInfinity) * 4 + (fcNaN)):
  assign(rhs);
  sign = false;
  [[fallthrough]];
case PackCategoriesIntoKey(fcNaN, fcZero)((fcNaN) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNaN, fcNormal)((fcNaN) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNaN, fcInfinity)((fcNaN) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcNaN, fcNaN)((fcNaN) * 4 + (fcNaN)):
  sign ^= rhs.sign; // restore the original sign
  if (isSignaling()) {
    makeQuiet();
    return opInvalidOp;
  }
  return rhs.isSignaling() ? opInvalidOp : opOK;

case PackCategoriesIntoKey(fcNormal, fcInfinity)((fcNormal) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcInfinity, fcNormal)((fcInfinity) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcInfinity, fcInfinity)((fcInfinity) * 4 + (fcInfinity)):
  category = fcInfinity;
  return opOK;

case PackCategoriesIntoKey(fcZero, fcNormal)((fcZero) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNormal, fcZero)((fcNormal) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcZero, fcZero)((fcZero) * 4 + (fcZero)):
  category = fcZero;
  return opOK;

case PackCategoriesIntoKey(fcZero, fcInfinity)((fcZero) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcInfinity, fcZero)((fcInfinity) * 4 + (fcZero)):
  makeNaN();
  return opInvalidOp;

case PackCategoriesIntoKey(fcNormal, fcNormal)((fcNormal) * 4 + (fcNormal)):
  return opOK;
}
1862}

1864IEEEFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
switch (PackCategoriesIntoKey(category, rhs.category)((category) * 4 + (rhs.category))) {
default:
  llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 1867);

case PackCategoriesIntoKey(fcZero, fcNaN)((fcZero) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcNormal, fcNaN)((fcNormal) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcInfinity, fcNaN)((fcInfinity) * 4 + (fcNaN)):
  assign(rhs);
  sign = false;
  [[fallthrough]];
case PackCategoriesIntoKey(fcNaN, fcZero)((fcNaN) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNaN, fcNormal)((fcNaN) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNaN, fcInfinity)((fcNaN) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcNaN, fcNaN)((fcNaN) * 4 + (fcNaN)):
  sign ^= rhs.sign; // restore the original sign
  if (isSignaling()) {
    makeQuiet();
    return opInvalidOp;
  }
  return rhs.isSignaling() ? opInvalidOp : opOK;

case PackCategoriesIntoKey(fcInfinity, fcZero)((fcInfinity) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcInfinity, fcNormal)((fcInfinity) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcZero, fcInfinity)((fcZero) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcNormal)((fcZero) * 4 + (fcNormal)):
  return opOK;

case PackCategoriesIntoKey(fcNormal, fcInfinity)((fcNormal) * 4 + (fcInfinity)):
  category = fcZero;
  return opOK;

case PackCategoriesIntoKey(fcNormal, fcZero)((fcNormal) * 4 + (fcZero)):
  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
    makeNaN(false, sign);
  else
    category = fcInfinity;
  return opDivByZero;

case PackCategoriesIntoKey(fcInfinity, fcInfinity)((fcInfinity) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcZero)((fcZero) * 4 + (fcZero)):
  makeNaN();
  return opInvalidOp;

case PackCategoriesIntoKey(fcNormal, fcNormal)((fcNormal) * 4 + (fcNormal)):
  return opOK;
}
1911}

1913IEEEFloat::opStatus IEEEFloat::modSpecials(const IEEEFloat &rhs) {
switch (PackCategoriesIntoKey(category, rhs.category)((category) * 4 + (rhs.category))) {
default:
  llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 1916);

case PackCategoriesIntoKey(fcZero, fcNaN)((fcZero) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcNormal, fcNaN)((fcNormal) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcInfinity, fcNaN)((fcInfinity) * 4 + (fcNaN)):
  assign(rhs);
  [[fallthrough]];
case PackCategoriesIntoKey(fcNaN, fcZero)((fcNaN) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNaN, fcNormal)((fcNaN) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNaN, fcInfinity)((fcNaN) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcNaN, fcNaN)((fcNaN) * 4 + (fcNaN)):
  if (isSignaling()) {
    makeQuiet();
    return opInvalidOp;
  }
  return rhs.isSignaling() ? opInvalidOp : opOK;

case PackCategoriesIntoKey(fcZero, fcInfinity)((fcZero) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcNormal)((fcZero) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNormal, fcInfinity)((fcNormal) * 4 + (fcInfinity)):
  return opOK;

case PackCategoriesIntoKey(fcNormal, fcZero)((fcNormal) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcInfinity, fcZero)((fcInfinity) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcInfinity, fcNormal)((fcInfinity) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcInfinity, fcInfinity)((fcInfinity) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcZero)((fcZero) * 4 + (fcZero)):
  makeNaN();
  return opInvalidOp;

case PackCategoriesIntoKey(fcNormal, fcNormal)((fcNormal) * 4 + (fcNormal)):
  return opOK;
}
1949}

1951IEEEFloat::opStatus IEEEFloat::remainderSpecials(const IEEEFloat &rhs) {
switch (PackCategoriesIntoKey(category, rhs.category)((category) * 4 + (rhs.category))) {
default:
  llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 1954);

case PackCategoriesIntoKey(fcZero, fcNaN)((fcZero) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcNormal, fcNaN)((fcNormal) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcInfinity, fcNaN)((fcInfinity) * 4 + (fcNaN)):
  assign(rhs);
  [[fallthrough]];
case PackCategoriesIntoKey(fcNaN, fcZero)((fcNaN) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNaN, fcNormal)((fcNaN) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNaN, fcInfinity)((fcNaN) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcNaN, fcNaN)((fcNaN) * 4 + (fcNaN)):
  if (isSignaling()) {
    makeQuiet();
    return opInvalidOp;
  }
  return rhs.isSignaling() ? opInvalidOp : opOK;

case PackCategoriesIntoKey(fcZero, fcInfinity)((fcZero) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcNormal)((fcZero) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNormal, fcInfinity)((fcNormal) * 4 + (fcInfinity)):
  return opOK;

case PackCategoriesIntoKey(fcNormal, fcZero)((fcNormal) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcInfinity, fcZero)((fcInfinity) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcInfinity, fcNormal)((fcInfinity) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcInfinity, fcInfinity)((fcInfinity) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcZero)((fcZero) * 4 + (fcZero)):
  makeNaN();
  return opInvalidOp;

case PackCategoriesIntoKey(fcNormal, fcNormal)((fcNormal) * 4 + (fcNormal)):
  return opDivByZero; // fake status, indicating this is not a special case
}
1987}

1989/* Change sign.  */
1990void IEEEFloat::changeSign() {
// With NaN-as-negative-zero, neither NaN or negative zero can change
// their signs.
if (semantics->nanEncoding == fltNanEncoding::NegativeZero &&
    (isZero() || isNaN()))
  return;
/* Look mummy, this one's easy.  */
sign = !sign;
1998}

2000/* Normalized addition or subtraction.  */
2001IEEEFloat::opStatus IEEEFloat::addOrSubtract(const IEEEFloat &rhs,
                                           roundingMode rounding_mode,
                                           bool subtract) {
opStatus fs;

fs = addOrSubtractSpecials(rhs, subtract);

/* This return code means it was not a simple case.  */
if (fs == opDivByZero) {
  lostFraction lost_fraction;

  lost_fraction = addOrSubtractSignificand(rhs, subtract);
  fs = normalize(rounding_mode, lost_fraction);

  /* Can only be zero if we lost no fraction.  */
  assert(category != fcZero || lost_fraction == lfExactlyZero)(static_cast <bool> (category != fcZero || lost_fraction
 == lfExactlyZero) ? void (0) : __assert_fail ("category != fcZero || lost_fraction == lfExactlyZero"
, "llvm/lib/Support/APFloat.cpp", 2016, __extension__ __PRETTY_FUNCTION__
));
}

/* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
   positive zero unless rounding to minus infinity, except that
   adding two like-signed zeroes gives that zero.  */
if (category == fcZero) {
  if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
    sign = (rounding_mode == rmTowardNegative);
  // NaN-in-negative-zero means zeros need to be normalized to +0.
  if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
    sign = false;
}

return fs;
2031}

2033/* Normalized addition.  */
2034IEEEFloat::opStatus IEEEFloat::add(const IEEEFloat &rhs,
                                 roundingMode rounding_mode) {
return addOrSubtract(rhs, rounding_mode, false);
2037}

2039/* Normalized subtraction.  */
2040IEEEFloat::opStatus IEEEFloat::subtract(const IEEEFloat &rhs,
                                      roundingMode rounding_mode) {
return addOrSubtract(rhs, rounding_mode, true);
2043}

2045/* Normalized multiply.  */
2046IEEEFloat::opStatus IEEEFloat::multiply(const IEEEFloat &rhs,
                                      roundingMode rounding_mode) {
opStatus fs;

sign ^= rhs.sign;
fs = multiplySpecials(rhs);

if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
  sign = false;
if (isFiniteNonZero()) {
  lostFraction lost_fraction = multiplySignificand(rhs);
  fs = normalize(rounding_mode, lost_fraction);
  if (lost_fraction != lfExactlyZero)
    fs = (opStatus) (fs | opInexact);
}

return fs;
2063}

2065/* Normalized divide.  */
2066IEEEFloat::opStatus IEEEFloat::divide(const IEEEFloat &rhs,
                                    roundingMode rounding_mode) {
opStatus fs;

sign ^= rhs.sign;
fs = divideSpecials(rhs);

if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
  sign = false;
if (isFiniteNonZero()) {
  lostFraction lost_fraction = divideSignificand(rhs);
  fs = normalize(rounding_mode, lost_fraction);
  if (lost_fraction != lfExactlyZero)
    fs = (opStatus) (fs | opInexact);
}

return fs;
2083}

2085/* Normalized remainder.  */
2086IEEEFloat::opStatus IEEEFloat::remainder(const IEEEFloat &rhs) {
opStatus fs;
unsigned int origSign = sign;

// First handle the special cases.
fs = remainderSpecials(rhs);
if (fs != opDivByZero)
  return fs;

fs = opOK;

// Make sure the current value is less than twice the denom. If the addition
// did not succeed (an overflow has happened), which means that the finite
// value we currently posses must be less than twice the denom (as we are
// using the same semantics).
IEEEFloat P2 = rhs;
if (P2.add(rhs, rmNearestTiesToEven) == opOK) {
  fs = mod(P2);
  assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2104, __extension__
 __PRETTY_FUNCTION__));
}

// Lets work with absolute numbers.
IEEEFloat P = rhs;
P.sign = false;
sign = false;

//
// To calculate the remainder we use the following scheme.
//
// The remainder is defained as follows:
//
// remainder = numer - rquot * denom = x - r * p
//
// Where r is the result of: x/p, rounded toward the nearest integral value
// (with halfway cases rounded toward the even number).
//
// Currently, (after x mod 2p):
// r is the number of 2p's present inside x, which is inherently, an even
// number of p's.
//
// We may split the remaining calculation into 4 options:
// - if x < 0.5p then we round to the nearest number with is 0, and are done.
// - if x == 0.5p then we round to the nearest even number which is 0, and we
//   are done as well.
// - if 0.5p < x < p then we round to nearest number which is 1, and we have
//   to subtract 1p at least once.
// - if x >= p then we must subtract p at least once, as x must be a
//   remainder.
//
// By now, we were done, or we added 1 to r, which in turn, now an odd number.
//
// We can now split the remaining calculation to the following 3 options:
// - if x < 0.5p then we round to the nearest number with is 0, and are done.
// - if x == 0.5p then we round to the nearest even number. As r is odd, we
//   must round up to the next even number. so we must subtract p once more.
// - if x > 0.5p (and inherently x < p) then we must round r up to the next
//   integral, and subtract p once more.
//

// Extend the semantics to prevent an overflow/underflow or inexact result.
bool losesInfo;
fltSemantics extendedSemantics = *semantics;
extendedSemantics.maxExponent++;
extendedSemantics.minExponent--;
extendedSemantics.precision += 2;

IEEEFloat VEx = *this;
fs = VEx.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 2154, __extension__ __PRETTY_FUNCTION__
));
IEEEFloat PEx = P;
fs = PEx.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 2157, __extension__ __PRETTY_FUNCTION__
));

// It is simpler to work with 2x instead of 0.5p, and we do not need to lose
// any fraction.
fs = VEx.add(VEx, rmNearestTiesToEven);
assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2162, __extension__
 __PRETTY_FUNCTION__));

if (VEx.compare(PEx) == cmpGreaterThan) {
  fs = subtract(P, rmNearestTiesToEven);
  assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2166, __extension__
 __PRETTY_FUNCTION__));

  // Make VEx = this.add(this), but because we have different semantics, we do
  // not want to `convert` again, so we just subtract PEx twice (which equals
  // to the desired value).
  fs = VEx.subtract(PEx, rmNearestTiesToEven);
  assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2172, __extension__
 __PRETTY_FUNCTION__));
  fs = VEx.subtract(PEx, rmNearestTiesToEven);
  assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2174, __extension__
 __PRETTY_FUNCTION__));

  cmpResult result = VEx.compare(PEx);
  if (result == cmpGreaterThan || result == cmpEqual) {
    fs = subtract(P, rmNearestTiesToEven);
    assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2179, __extension__
 __PRETTY_FUNCTION__));
  }
}

if (isZero()) {
  sign = origSign;    // IEEE754 requires this
  if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
    // But some 8-bit floats only have positive 0.
    sign = false;
}

else
  sign ^= origSign;
return fs;
2193}

2195/* Normalized llvm frem (C fmod). */
2196IEEEFloat::opStatus IEEEFloat::mod(const IEEEFloat &rhs) {
opStatus fs;
fs = modSpecials(rhs);
unsigned int origSign = sign;

while (isFiniteNonZero() && rhs.isFiniteNonZero() &&
       compareAbsoluteValue(rhs) != cmpLessThan) {
  int Exp = ilogb(*this) - ilogb(rhs);
  IEEEFloat V = scalbn(rhs, Exp, rmNearestTiesToEven);
  // V can overflow to NaN with fltNonfiniteBehavior::NanOnly, so explicitly
  // check for it.
  if (V.isNaN() || compareAbsoluteValue(V) == cmpLessThan)
    V = scalbn(rhs, Exp - 1, rmNearestTiesToEven);
  V.sign = sign;

  fs = subtract(V, rmNearestTiesToEven);
  assert(fs==opOK)(static_cast <bool> (fs==opOK) ? void (0) : __assert_fail
 ("fs==opOK", "llvm/lib/Support/APFloat.cpp", 2212, __extension__
 __PRETTY_FUNCTION__));
}
if (isZero()) {
  sign = origSign; // fmod requires this
  if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
    sign = false;
}
return fs;
2220}

2222/* Normalized fused-multiply-add.  */
2223IEEEFloat::opStatus IEEEFloat::fusedMultiplyAdd(const IEEEFloat &multiplicand,
                                              const IEEEFloat &addend,
                                              roundingMode rounding_mode) {
opStatus fs;

/* Post-multiplication sign, before addition.  */
sign ^= multiplicand.sign;

/* If and only if all arguments are normal do we need to do an
   extended-precision calculation.  */
if (isFiniteNonZero() &&
    multiplicand.isFiniteNonZero() &&
    addend.isFinite()) {
  lostFraction lost_fraction;

  lost_fraction = multiplySignificand(multiplicand, addend);
  fs = normalize(rounding_mode, lost_fraction);
  if (lost_fraction != lfExactlyZero)
    fs = (opStatus) (fs | opInexact);

  /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
     positive zero unless rounding to minus infinity, except that
     adding two like-signed zeroes gives that zero.  */
  if (category == fcZero && !(fs & opUnderflow) && sign != addend.sign) {
    sign = (rounding_mode == rmTowardNegative);
    if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
      sign = false;
  }
} else {
  fs = multiplySpecials(multiplicand);

  /* FS can only be opOK or opInvalidOp.  There is no more work
     to do in the latter case.  The IEEE-754R standard says it is
     implementation-defined in this case whether, if ADDEND is a
     quiet NaN, we raise invalid op; this implementation does so.

     If we need to do the addition we can do so with normal
     precision.  */
  if (fs == opOK)
    fs = addOrSubtract(addend, rounding_mode, false);
}

return fs;
2266}

2268/* Rounding-mode correct round to integral value.  */
2269IEEEFloat::opStatus IEEEFloat::roundToIntegral(roundingMode rounding_mode) {
opStatus fs;

if (isInfinity())
  // [IEEE Std 754-2008 6.1]:
  // The behavior of infinity in floating-point arithmetic is derived from the
  // limiting cases of real arithmetic with operands of arbitrarily
  // large magnitude, when such a limit exists.
  // ...
  // Operations on infinite operands are usually exact and therefore signal no
  // exceptions ...
  return opOK;

if (isNaN()) {
  if (isSignaling()) {
    // [IEEE Std 754-2008 6.2]:
    // Under default exception handling, any operation signaling an invalid
    // operation exception and for which a floating-point result is to be
    // delivered shall deliver a quiet NaN.
    makeQuiet();
    // [IEEE Std 754-2008 6.2]:
    // Signaling NaNs shall be reserved operands that, under default exception
    // handling, signal the invalid operation exception(see 7.2) for every
    // general-computational and signaling-computational operation except for
    // the conversions described in 5.12.
    return opInvalidOp;
  } else {
    // [IEEE Std 754-2008 6.2]:
    // For an operation with quiet NaN inputs, other than maximum and minimum
    // operations, if a floating-point result is to be delivered the result
    // shall be a quiet NaN which should be one of the input NaNs.
    // ...
    // Every general-computational and quiet-computational operation involving
    // one or more input NaNs, none of them signaling, shall signal no
    // exception, except fusedMultiplyAdd might signal the invalid operation
    // exception(see 7.2).
    return opOK;
  }
}

if (isZero()) {
  // [IEEE Std 754-2008 6.3]:
  // ... the sign of the result of conversions, the quantize operation, the
  // roundToIntegral operations, and the roundToIntegralExact(see 5.3.1) is
  // the sign of the first or only operand.
  return opOK;
}

// If the exponent is large enough, we know that this value is already
// integral, and the arithmetic below would potentially cause it to saturate
// to +/-Inf.  Bail out early instead.
if (exponent+1 >= (int)semanticsPrecision(*semantics))
  return opOK;

// The algorithm here is quite simple: we add 2^(p-1), where p is the
// precision of our format, and then subtract it back off again.  The choice
// of rounding modes for the addition/subtraction determines the rounding mode
// for our integral rounding as well.
// NOTE: When the input value is negative, we do subtraction followed by
// addition instead.
APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
IntegerConstant <<= semanticsPrecision(*semantics)-1;
IEEEFloat MagicConstant(*semantics);
fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
                                    rmNearestTiesToEven);
assert(fs == opOK)(static_cast <bool> (fs == opOK) ? void (0) : __assert_fail
 ("fs == opOK", "llvm/lib/Support/APFloat.cpp", 2334, __extension__
 __PRETTY_FUNCTION__));
MagicConstant.sign = sign;

// Preserve the input sign so that we can handle the case of zero result
// correctly.
bool inputSign = isNegative();

fs = add(MagicConstant, rounding_mode);

// Current value and 'MagicConstant' are both integers, so the result of the
// subtraction is always exact according to Sterbenz' lemma.
subtract(MagicConstant, rounding_mode);

// Restore the input sign.
if (inputSign != isNegative())
  changeSign();

return fs;
2352}


2355/* Comparison requires normalized numbers.  */
2356IEEEFloat::cmpResult IEEEFloat::compare(const IEEEFloat &rhs) const {
cmpResult result;

assert(semantics == rhs.semantics)(static_cast <bool> (semantics == rhs.semantics) ? void
 (0) : __assert_fail ("semantics == rhs.semantics", "llvm/lib/Support/APFloat.cpp"
, 2359, __extension__ __PRETTY_FUNCTION__));

switch (PackCategoriesIntoKey(category, rhs.category)((category) * 4 + (rhs.category))) {
default:
  llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 2363);

case PackCategoriesIntoKey(fcNaN, fcZero)((fcNaN) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNaN, fcNormal)((fcNaN) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcNaN, fcInfinity)((fcNaN) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcNaN, fcNaN)((fcNaN) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcZero, fcNaN)((fcZero) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcNormal, fcNaN)((fcNormal) * 4 + (fcNaN)):
case PackCategoriesIntoKey(fcInfinity, fcNaN)((fcInfinity) * 4 + (fcNaN)):
  return cmpUnordered;

case PackCategoriesIntoKey(fcInfinity, fcNormal)((fcInfinity) * 4 + (fcNormal)):
case PackCategoriesIntoKey(fcInfinity, fcZero)((fcInfinity) * 4 + (fcZero)):
case PackCategoriesIntoKey(fcNormal, fcZero)((fcNormal) * 4 + (fcZero)):
  if (sign)
    return cmpLessThan;
  else
    return cmpGreaterThan;

case PackCategoriesIntoKey(fcNormal, fcInfinity)((fcNormal) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcInfinity)((fcZero) * 4 + (fcInfinity)):
case PackCategoriesIntoKey(fcZero, fcNormal)((fcZero) * 4 + (fcNormal)):
  if (rhs.sign)
    return cmpGreaterThan;
  else
    return cmpLessThan;

case PackCategoriesIntoKey(fcInfinity, fcInfinity)((fcInfinity) * 4 + (fcInfinity)):
  if (sign == rhs.sign)
    return cmpEqual;
  else if (sign)
    return cmpLessThan;
  else
    return cmpGreaterThan;

case PackCategoriesIntoKey(fcZero, fcZero)((fcZero) * 4 + (fcZero)):
  return cmpEqual;

case PackCategoriesIntoKey(fcNormal, fcNormal)((fcNormal) * 4 + (fcNormal)):
  break;
}

/* Two normal numbers.  Do they have the same sign?  */
if (sign != rhs.sign) {
  if (sign)
    result = cmpLessThan;
  else
    result = cmpGreaterThan;
} else {
  /* Compare absolute values; invert result if negative.  */
  result = compareAbsoluteValue(rhs);

  if (sign) {
    if (result == cmpLessThan)
      result = cmpGreaterThan;
    else if (result == cmpGreaterThan)
      result = cmpLessThan;
  }
}

return result;
2424}

2426/// IEEEFloat::convert - convert a value of one floating point type to another.
2427/// The return value corresponds to the IEEE754 exceptions.  *losesInfo
2428/// records whether the transformation lost information, i.e. whether
2429/// converting the result back to the original type will produce the
2430/// original value (this is almost the same as return value==fsOK, but there
2431/// are edge cases where this is not so).

2433IEEEFloat::opStatus IEEEFloat::convert(const fltSemantics &toSemantics,
                                     roundingMode rounding_mode,
                                     bool *losesInfo) {
lostFraction lostFraction;
unsigned int newPartCount, oldPartCount;
opStatus fs;
int shift;
const fltSemantics &fromSemantics = *semantics;
bool is_signaling = isSignaling();

lostFraction = lfExactlyZero;
newPartCount = partCountForBits(toSemantics.precision + 1);
oldPartCount = partCount();
shift = toSemantics.precision - fromSemantics.precision;

bool X86SpecialNan = false;
if (&fromSemantics == &semX87DoubleExtended &&
    &toSemantics != &semX87DoubleExtended && category == fcNaN &&
    (!(*significandParts() & 0x8000000000000000ULL) ||
     !(*significandParts() & 0x4000000000000000ULL))) {
  // x86 has some unusual NaNs which cannot be represented in any other
  // format; note them here.
  X86SpecialNan = true;
}

// If this is a truncation of a denormal number, and the target semantics
// has larger exponent range than the source semantics (this can happen
// when truncating from PowerPC double-double to double format), the
// right shift could lose result mantissa bits.  Adjust exponent instead
// of performing excessive shift.
// Also do a similar trick in case shifting denormal would produce zero
// significand as this case isn't handled correctly by normalize.
if (shift < 0 && isFiniteNonZero()) {
  int omsb = significandMSB() + 1;
  int exponentChange = omsb - fromSemantics.precision;
  if (exponent + exponentChange < toSemantics.minExponent)
    exponentChange = toSemantics.minExponent - exponent;
  if (exponentChange < shift)
    exponentChange = shift;
  if (exponentChange < 0) {
    shift -= exponentChange;
    exponent += exponentChange;
  } else if (omsb <= -shift) {
    exponentChange = omsb + shift - 1; // leave at least one bit set
    shift -= exponentChange;
    exponent += exponentChange;
  }
}

// If this is a truncation, perform the shift before we narrow the storage.
if (shift < 0 && (isFiniteNonZero() ||
                  (category == fcNaN && semantics->nonFiniteBehavior !=
                                            fltNonfiniteBehavior::NanOnly)))
  lostFraction = shiftRight(significandParts(), oldPartCount, -shift);

// Fix the storage so it can hold to new value.
if (newPartCount > oldPartCount) {
  // The new type requires more storage; make it available.
  integerPart *newParts;
  newParts = new integerPart[newPartCount];
  APInt::tcSet(newParts, 0, newPartCount);
  if (isFiniteNonZero() || category==fcNaN)
    APInt::tcAssign(newParts, significandParts(), oldPartCount);
  freeSignificand();
  significand.parts = newParts;
} else if (newPartCount == 1 && oldPartCount != 1) {
  // Switch to built-in storage for a single part.
  integerPart newPart = 0;
  if (isFiniteNonZero() || category==fcNaN)
    newPart = significandParts()[0];
  freeSignificand();
  significand.part = newPart;
}

// Now that we have the right storage, switch the semantics.
semantics = &toSemantics;

// If this is an extension, perform the shift now that the storage is
// available.
if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
  APInt::tcShiftLeft(significandParts(), newPartCount, shift);

if (isFiniteNonZero()) {
  fs = normalize(rounding_mode, lostFraction);
  *losesInfo = (fs != opOK);
} else if (category == fcNaN) {
  if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
    *losesInfo =
        fromSemantics.nonFiniteBehavior != fltNonfiniteBehavior::NanOnly;
    makeNaN(false, sign);
    return is_signaling ? opInvalidOp : opOK;
  }

  // If NaN is negative zero, we need to create a new NaN to avoid converting
  // NaN to -Inf.
  if (fromSemantics.nanEncoding == fltNanEncoding::NegativeZero &&
      semantics->nanEncoding != fltNanEncoding::NegativeZero)
    makeNaN(false, false);

  *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;

  // For x87 extended precision, we want to make a NaN, not a special NaN if
  // the input wasn't special either.
  if (!X86SpecialNan && semantics == &semX87DoubleExtended)
    APInt::tcSetBit(significandParts(), semantics->precision - 1);

  // Convert of sNaN creates qNaN and raises an exception (invalid op).
  // This also guarantees that a sNaN does not become Inf on a truncation
  // that loses all payload bits.
  if (is_signaling) {
    makeQuiet();
    fs = opInvalidOp;
  } else {
    fs = opOK;
  }
} else if (category == fcInfinity &&
           semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
  makeNaN(false, sign);
  *losesInfo = true;
  fs = opInexact;
} else if (category == fcZero &&
           semantics->nanEncoding == fltNanEncoding::NegativeZero) {
  // Negative zero loses info, but positive zero doesn't.
  *losesInfo =
      fromSemantics.nanEncoding != fltNanEncoding::NegativeZero && sign;
  fs = *losesInfo ? opInexact : opOK;
  // NaN is negative zero means -0 -> +0, which can lose information
  sign = false;
} else {
  *losesInfo = false;
  fs = opOK;
}

return fs;
2567}

2569/* Convert a floating point number to an integer according to the
 rounding mode.  If the rounded integer value is out of range this
 returns an invalid operation exception and the contents of the
 destination parts are unspecified.  If the rounded value is in
 range but the floating point number is not the exact integer, the C
 standard doesn't require an inexact exception to be raised.  IEEE
 854 does require it so we do that.

 Note that for conversions to integer type the C standard requires
 round-to-zero to always be used.  */
2579IEEEFloat::opStatus IEEEFloat::convertToSignExtendedInteger(
  MutableArrayRef<integerPart> parts, unsigned int width, bool isSigned,
  roundingMode rounding_mode, bool *isExact) const {
lostFraction lost_fraction;
const integerPart *src;
unsigned int dstPartsCount, truncatedBits;

*isExact = false;

/* Handle the three special cases first.  */
if (category == fcInfinity || category == fcNaN)
  return opInvalidOp;

dstPartsCount = partCountForBits(width);
assert(dstPartsCount <= parts.size() && "Integer too big")(static_cast <bool> (dstPartsCount <= parts.size() &&
 "Integer too big") ? void (0) : __assert_fail ("dstPartsCount <= parts.size() && \"Integer too big\""
, "llvm/lib/Support/APFloat.cpp", 2593, __extension__ __PRETTY_FUNCTION__
));

if (category == fcZero) {
  APInt::tcSet(parts.data(), 0, dstPartsCount);
  // Negative zero can't be represented as an int.
  *isExact = !sign;
  return opOK;
}

src = significandParts();

/* Step 1: place our absolute value, with any fraction truncated, in
   the destination.  */
if (exponent < 0) {
  /* Our absolute value is less than one; truncate everything.  */
  APInt::tcSet(parts.data(), 0, dstPartsCount);
  /* For exponent -1 the integer bit represents .5, look at that.
     For smaller exponents leftmost truncated bit is 0. */
  truncatedBits = semantics->precision -1U - exponent;
} else {
  /* We want the most significant (exponent + 1) bits; the rest are
     truncated.  */
  unsigned int bits = exponent + 1U;

  /* Hopelessly large in magnitude?  */
  if (bits > width)
    return opInvalidOp;

  if (bits < semantics->precision) {
    /* We truncate (semantics->precision - bits) bits.  */
    truncatedBits = semantics->precision - bits;
    APInt::tcExtract(parts.data(), dstPartsCount, src, bits, truncatedBits);
  } else {
    /* We want at least as many bits as are available.  */
    APInt::tcExtract(parts.data(), dstPartsCount, src, semantics->precision,
                     0);
    APInt::tcShiftLeft(parts.data(), dstPartsCount,
                       bits - semantics->precision);
    truncatedBits = 0;
  }
}

/* Step 2: work out any lost fraction, and increment the absolute
   value if we would round away from zero.  */
if (truncatedBits) {
  lost_fraction = lostFractionThroughTruncation(src, partCount(),
                                                truncatedBits);
  if (lost_fraction != lfExactlyZero &&
      roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
    if (APInt::tcIncrement(parts.data(), dstPartsCount))
      return opInvalidOp;     /* Overflow.  */
  }
} else {
  lost_fraction = lfExactlyZero;
}

/* Step 3: check if we fit in the destination.  */
unsigned int omsb = APInt::tcMSB(parts.data(), dstPartsCount) + 1;

if (sign) {
  if (!isSigned) {
    /* Negative numbers cannot be represented as unsigned.  */
    if (omsb != 0)
      return opInvalidOp;
  } else {
    /* It takes omsb bits to represent the unsigned integer value.
       We lose a bit for the sign, but care is needed as the
       maximally negative integer is a special case.  */
    if (omsb == width &&
        APInt::tcLSB(parts.data(), dstPartsCount) + 1 != omsb)
      return opInvalidOp;

    /* This case can happen because of rounding.  */
    if (omsb > width)
      return opInvalidOp;
  }

  APInt::tcNegate (parts.data(), dstPartsCount);
} else {
  if (omsb >= width + !isSigned)
    return opInvalidOp;
}

if (lost_fraction == lfExactlyZero) {
  *isExact = true;
  return opOK;
} else
  return opInexact;
2681}

2683/* Same as convertToSignExtendedInteger, except we provide
 deterministic values in case of an invalid operation exception,
 namely zero for NaNs and the minimal or maximal value respectively
 for underflow or overflow.
 The *isExact output tells whether the result is exact, in the sense
 that converting it back to the original floating point type produces
 the original value.  This is almost equivalent to result==opOK,
 except for negative zeroes.
2691*/
2692IEEEFloat::opStatus
2693IEEEFloat::convertToInteger(MutableArrayRef<integerPart> parts,
                          unsigned int width, bool isSigned,
                          roundingMode rounding_mode, bool *isExact) const {
opStatus fs;

fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
                                  isExact);

if (fs == opInvalidOp) {
  unsigned int bits, dstPartsCount;

  dstPartsCount = partCountForBits(width);
  assert(dstPartsCount <= parts.size() && "Integer too big")(static_cast <bool> (dstPartsCount <= parts.size() &&
 "Integer too big") ? void (0) : __assert_fail ("dstPartsCount <= parts.size() && \"Integer too big\""
, "llvm/lib/Support/APFloat.cpp", 2705, __extension__ __PRETTY_FUNCTION__
));

  if (category == fcNaN)
    bits = 0;
  else if (sign)
    bits = isSigned;
  else
    bits = width - isSigned;

  tcSetLeastSignificantBits(parts.data(), dstPartsCount, bits);
  if (sign && isSigned)
    APInt::tcShiftLeft(parts.data(), dstPartsCount, width - 1);
}

return fs;
2720}

2722/* Convert an unsigned integer SRC to a floating point number,
 rounding according to ROUNDING_MODE.  The sign of the floating
 point number is not modified.  */
2725IEEEFloat::opStatus IEEEFloat::convertFromUnsignedParts(
  const integerPart *src, unsigned int srcCount, roundingMode rounding_mode) {
unsigned int omsb, precision, dstCount;
integerPart *dst;
lostFraction lost_fraction;

category = fcNormal;
omsb = APInt::tcMSB(src, srcCount) + 1;
dst = significandParts();
dstCount = partCount();
precision = semantics->precision;

/* We want the most significant PRECISION bits of SRC.  There may not
   be that many; extract what we can.  */
if (precision <= omsb) {
  exponent = omsb - 1;
  lost_fraction = lostFractionThroughTruncation(src, srcCount,
                                                omsb - precision);
  APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
} else {
  exponent = precision - 1;
  lost_fraction = lfExactlyZero;
  APInt::tcExtract(dst, dstCount, src, omsb, 0);
}

return normalize(rounding_mode, lost_fraction);
2751}

2753IEEEFloat::opStatus IEEEFloat::convertFromAPInt(const APInt &Val, bool isSigned,
                                              roundingMode rounding_mode) {
unsigned int partCount = Val.getNumWords();
APInt api = Val;

sign = false;
if (isSigned && api.isNegative()) {
  sign = true;
  api = -api;
}

return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2765}

2767/* Convert a two's complement integer SRC to a floating point number,
 rounding according to ROUNDING_MODE.  ISSIGNED is true if the
 integer is signed, in which case it must be sign-extended.  */
2770IEEEFloat::opStatus
2771IEEEFloat::convertFromSignExtendedInteger(const integerPart *src,
                                        unsigned int srcCount, bool isSigned,
                                        roundingMode rounding_mode) {
opStatus status;

if (isSigned &&
    APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
  integerPart *copy;

  /* If we're signed and negative negate a copy.  */
  sign = true;
  copy = new integerPart[srcCount];
  APInt::tcAssign(copy, src, srcCount);
  APInt::tcNegate(copy, srcCount);
  status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
  delete [] copy;
} else {
  sign = false;
  status = convertFromUnsignedParts(src, srcCount, rounding_mode);
}

return status;
2793}

2795/* FIXME: should this just take a const APInt reference?  */
2796IEEEFloat::opStatus
2797IEEEFloat::convertFromZeroExtendedInteger(const integerPart *parts,
                                        unsigned int width, bool isSigned,
                                        roundingMode rounding_mode) {
unsigned int partCount = partCountForBits(width);
APInt api = APInt(width, ArrayRef(parts, partCount));

sign = false;
if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
  sign = true;
  api = -api;
}

return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2810}

2812Expected<IEEEFloat::opStatus>
2813IEEEFloat::convertFromHexadecimalString(StringRef s,
                                      roundingMode rounding_mode) {
lostFraction lost_fraction = lfExactlyZero;

category = fcNormal;
zeroSignificand();
exponent = 0;

integerPart *significand = significandParts();
unsigned partsCount = partCount();
unsigned bitPos = partsCount * integerPartWidth;
bool computedTrailingFraction = false;

// Skip leading zeroes and any (hexa)decimal point.
StringRef::iterator begin = s.begin();
StringRef::iterator end = s.end();
StringRef::iterator dot;
auto PtrOrErr = skipLeadingZeroesAndAnyDot(begin, end, &dot);
if (!PtrOrErr)
  return PtrOrErr.takeError();
StringRef::iterator p = *PtrOrErr;
StringRef::iterator firstSignificantDigit = p;

while (p != end) {
  integerPart hex_value;

  if (*p == '.') {
    if (dot != end)
      return createError("String contains multiple dots");
    dot = p++;
    continue;
  }

  hex_value = hexDigitValue(*p);
  if (hex_value == UINT_MAX(2147483647 *2U +1U))
    break;

  p++;

  // Store the number while we have space.
  if (bitPos) {
    bitPos -= 4;
    hex_value <<= bitPos % integerPartWidth;
    significand[bitPos / integerPartWidth] |= hex_value;
  } else if (!computedTrailingFraction) {
    auto FractOrErr = trailingHexadecimalFraction(p, end, hex_value);
    if (!FractOrErr)
      return FractOrErr.takeError();
    lost_fraction = *FractOrErr;
    computedTrailingFraction = true;
  }
}

/* Hex floats require an exponent but not a hexadecimal point.  */
if (p == end)
  return createError("Hex strings require an exponent");
if (*p != 'p' && *p != 'P')
  return createError("Invalid character in significand");
if (p == begin)
  return createError("Significand has no digits");
if (dot != end && p - begin == 1)
  return createError("Significand has no digits");

/* Ignore the exponent if we are zero.  */
if (p != firstSignificantDigit) {
  int expAdjustment;

  /* Implicit hexadecimal point?  */
  if (dot == end)
    dot = p;

  /* Calculate the exponent adjustment implicit in the number of
     significant digits.  */
  expAdjustment = static_cast<int>(dot - firstSignificantDigit);
  if (expAdjustment < 0)
    expAdjustment++;
  expAdjustment = expAdjustment * 4 - 1;

  /* Adjust for writing the significand starting at the most
     significant nibble.  */
  expAdjustment += semantics->precision;
  expAdjustment -= partsCount * integerPartWidth;

  /* Adjust for the given exponent.  */
  auto ExpOrErr = totalExponent(p + 1, end, expAdjustment);
  if (!ExpOrErr)
    return ExpOrErr.takeError();
  exponent = *ExpOrErr;
}

return normalize(rounding_mode, lost_fraction);
2904}

2906IEEEFloat::opStatus
2907IEEEFloat::roundSignificandWithExponent(const integerPart *decSigParts,
                                      unsigned sigPartCount, int exp,
                                      roundingMode rounding_mode) {
unsigned int parts, pow5PartCount;
fltSemantics calcSemantics = { 32767, -32767, 0, 0 };
integerPart pow5Parts[maxPowerOfFiveParts];
bool isNearest;

isNearest = (rounding_mode == rmNearestTiesToEven ||
             rounding_mode == rmNearestTiesToAway);

parts = partCountForBits(semantics->precision + 11);

/* Calculate pow(5, abs(exp)).  */
pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);

for (;; parts *= 2) {
  opStatus sigStatus, powStatus;
  unsigned int excessPrecision, truncatedBits;

  calcSemantics.precision = parts * integerPartWidth - 1;
  excessPrecision = calcSemantics.precision - semantics->precision;
  truncatedBits = excessPrecision;

  IEEEFloat decSig(calcSemantics, uninitialized);
  decSig.makeZero(sign);
  IEEEFloat pow5(calcSemantics);

  sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
                                              rmNearestTiesToEven);
  powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
                                            rmNearestTiesToEven);
  /* Add exp, as 10^n = 5^n * 2^n.  */
  decSig.exponent += exp;

  lostFraction calcLostFraction;
  integerPart HUerr, HUdistance;
  unsigned int powHUerr;

  if (exp >= 0) {
    /* multiplySignificand leaves the precision-th bit set to 1.  */
    calcLostFraction = decSig.multiplySignificand(pow5);
    powHUerr = powStatus != opOK;
  } else {
    calcLostFraction = decSig.divideSignificand(pow5);
    /* Denormal numbers have less precision.  */
    if (decSig.exponent < semantics->minExponent) {
      excessPrecision += (semantics->minExponent - decSig.exponent);
      truncatedBits = excessPrecision;
      if (excessPrecision > calcSemantics.precision)
        excessPrecision = calcSemantics.precision;
    }
    /* Extra half-ulp lost in reciprocal of exponent.  */
    powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
  }

  /* Both multiplySignificand and divideSignificand return the
     result with the integer bit set.  */
  assert(APInt::tcExtractBit(static_cast <bool> (APInt::tcExtractBit (decSig.significandParts
(), calcSemantics.precision - 1) == 1) ? void (0) : __assert_fail
 ("APInt::tcExtractBit (decSig.significandParts(), calcSemantics.precision - 1) == 1"
, "llvm/lib/Support/APFloat.cpp", 2966, __extension__ __PRETTY_FUNCTION__
))
         (decSig.significandParts(), calcSemantics.precision - 1) == 1)(static_cast <bool> (APInt::tcExtractBit (decSig.significandParts
(), calcSemantics.precision - 1) == 1) ? void (0) : __assert_fail
 ("APInt::tcExtractBit (decSig.significandParts(), calcSemantics.precision - 1) == 1"
, "llvm/lib/Support/APFloat.cpp", 2966, __extension__ __PRETTY_FUNCTION__
));

  HUerr = HUerrBound(calcLostFraction != lfExactlyZero, sigStatus != opOK,
                     powHUerr);
  HUdistance = 2 * ulpsFromBoundary(decSig.significandParts(),
                                    excessPrecision, isNearest);

  /* Are we guaranteed to round correctly if we truncate?  */
  if (HUdistance >= HUerr) {
    APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
                     calcSemantics.precision - excessPrecision,
                     excessPrecision);
    /* Take the exponent of decSig.  If we tcExtract-ed less bits
       above we must adjust our exponent to compensate for the
       implicit right shift.  */
    exponent = (decSig.exponent + semantics->precision
                - (calcSemantics.precision - excessPrecision));
    calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
                                                     decSig.partCount(),
                                                     truncatedBits);
    return normalize(rounding_mode, calcLostFraction);
  }
}
2989}

2991Expected<IEEEFloat::opStatus>
2992IEEEFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode) {
decimalInfo D;
opStatus fs;

/* Scan the text.  */
StringRef::iterator p = str.begin();
if (Error Err = interpretDecimal(p, str.end(), &D))
  return std::move(Err);

/* Handle the quick cases.  First the case of no significant digits,
   i.e. zero, and then exponents that are obviously too large or too
   small.  Writing L for log 10 / log 2, a number d.ddddd*10^exp
   definitely overflows if

         (exp - 1) * L >= maxExponent

   and definitely underflows to zero where

         (exp + 1) * L <= minExponent - precision

   With integer arithmetic the tightest bounds for L are

         93/28 < L < 196/59            [ numerator <= 256 ]
         42039/12655 < L < 28738/8651  [ numerator <= 65536 ]
*/

// Test if we have a zero number allowing for strings with no null terminators
// and zero decimals with non-zero exponents.
//
// We computed firstSigDigit by ignoring all zeros and dots. Thus if
// D->firstSigDigit equals str.end(), every digit must be a zero and there can
// be at most one dot. On the other hand, if we have a zero with a non-zero
// exponent, then we know that D.firstSigDigit will be non-numeric.
if (D.firstSigDigit == str.end() || decDigitValue(*D.firstSigDigit) >= 10U) {
  category = fcZero;
  fs = opOK;
  if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
    sign = false;

  /* Check whether the normalized exponent is high enough to overflow
     max during the log-rebasing in the max-exponent check below. */
} else if (D.normalizedExponent - 1 > INT_MAX2147483647 / 42039) {
  fs = handleOverflow(rounding_mode);

/* If it wasn't, then it also wasn't high enough to overflow max
   during the log-rebasing in the min-exponent check.  Check that it
   won't overflow min in either check, then perform the min-exponent
   check. */
} else if (D.normalizedExponent - 1 < INT_MIN(-2147483647 -1) / 42039 ||
           (D.normalizedExponent + 1) * 28738 <=
             8651 * (semantics->minExponent - (int) semantics->precision)) {
  /* Underflow to zero and round.  */
  category = fcNormal;
  zeroSignificand();
  fs = normalize(rounding_mode, lfLessThanHalf);

/* We can finally safely perform the max-exponent check. */
} else if ((D.normalizedExponent - 1) * 42039
           >= 12655 * semantics->maxExponent) {
  /* Overflow and round.  */
  fs = handleOverflow(rounding_mode);
} else {
  integerPart *decSignificand;
  unsigned int partCount;

  /* A tight upper bound on number of bits required to hold an
     N-digit decimal integer is N * 196 / 59.  Allocate enough space
     to hold the full significand, and an extra part required by
     tcMultiplyPart.  */
  partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
  partCount = partCountForBits(1 + 196 * partCount / 59);
  decSignificand = new integerPart[partCount + 1];
  partCount = 0;

  /* Convert to binary efficiently - we do almost all multiplication
     in an integerPart.  When this would overflow do we do a single
     bignum multiplication, and then revert again to multiplication
     in an integerPart.  */
  do {
    integerPart decValue, val, multiplier;

    val = 0;
    multiplier = 1;

    do {
      if (*p == '.') {
        p++;
        if (p == str.end()) {
          break;
        }
      }
      decValue = decDigitValue(*p++);
      if (decValue >= 10U) {
        delete[] decSignificand;
        return createError("Invalid character in significand");
      }
      multiplier *= 10;
      val = val * 10 + decValue;
      /* The maximum number that can be multiplied by ten with any
         digit added without overflowing an integerPart.  */
    } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);

    /* Multiply out the current part.  */
    APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
                          partCount, partCount + 1, false);

    /* If we used another part (likely but not guaranteed), increase
       the count.  */
    if (decSignificand[partCount])
      partCount++;
  } while (p <= D.lastSigDigit);

  category = fcNormal;
  fs = roundSignificandWithExponent(decSignificand, partCount,
                                    D.exponent, rounding_mode);

  delete [] decSignificand;
}

return fs;
3112}

3114bool IEEEFloat::convertFromStringSpecials(StringRef str) {
const size_t MIN_NAME_SIZE = 3;

if (str.size() < MIN_NAME_SIZE)
  return false;

if (str.equals("inf") || str.equals("INFINITY") || str.equals("+Inf")) {
  makeInf(false);
  return true;
}

bool IsNegative = str.front() == '-';
if (IsNegative) {
  str = str.drop_front();
  if (str.size() < MIN_NAME_SIZE)
    return false;

  if (str.equals("inf") || str.equals("INFINITY") || str.equals("Inf")) {
    makeInf(true);
    return true;
  }
}

// If we have a 's' (or 'S') prefix, then this is a Signaling NaN.
bool IsSignaling = str.front() == 's' || str.front() == 'S';
if (IsSignaling) {
  str = str.drop_front();
  if (str.size() < MIN_NAME_SIZE)
    return false;
}

if (str.startswith("nan") || str.startswith("NaN")) {
  str = str.drop_front(3);

  // A NaN without payload.
  if (str.empty()) {
    makeNaN(IsSignaling, IsNegative);
    return true;
  }

  // Allow the payload to be inside parentheses.
  if (str.front() == '(') {
    // Parentheses should be balanced (and not empty).
    if (str.size() <= 2 || str.back() != ')')
      return false;

    str = str.slice(1, str.size() - 1);
  }

  // Determine the payload number's radix.
  unsigned Radix = 10;
  if (str[0] == '0') {
    if (str.size() > 1 && tolower(str[1]) == 'x') {
      str = str.drop_front(2);
      Radix = 16;
    } else
      Radix = 8;
  }

  // Parse the payload and make the NaN.
  APInt Payload;
  if (!str.getAsInteger(Radix, Payload)) {
    makeNaN(IsSignaling, IsNegative, &Payload);
    return true;
  }
}

return false;
3182}

3184Expected<IEEEFloat::opStatus>
3185IEEEFloat::convertFromString(StringRef str, roundingMode rounding_mode) {
if (str.empty())
  return createError("Invalid string length");

// Handle special cases.
if (convertFromStringSpecials(str))
  return opOK;

/* Handle a leading minus sign.  */
StringRef::iterator p = str.begin();
size_t slen = str.size();
sign = *p == '-' ? 1 : 0;
if (*p == '-' || *p == '+') {
  p++;
  slen--;
  if (!slen)
    return createError("String has no digits");
}

if (slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
  if (slen == 2)
    return createError("Invalid string");
  return convertFromHexadecimalString(StringRef(p + 2, slen - 2),
                                      rounding_mode);
}

return convertFromDecimalString(StringRef(p, slen), rounding_mode);
3212}

3214/* Write out a hexadecimal representation of the floating point value
 to DST, which must be of sufficient size, in the C99 form
 [-]0xh.hhhhp[+-]d.  Return the number of characters written,
 excluding the terminating NUL.

 If UPPERCASE, the output is in upper case, otherwise in lower case.

 HEXDIGITS digits appear altogether, rounding the value if
 necessary.  If HEXDIGITS is 0, the minimal precision to display the
 number precisely is used instead.  If nothing would appear after
 the decimal point it is suppressed.

 The decimal exponent is always printed and has at least one digit.
 Zero values display an exponent of zero.  Infinities and NaNs
 appear as "infinity" or "nan" respectively.

 The above rules are as specified by C99.  There is ambiguity about
 what the leading hexadecimal digit should be.  This implementation
 uses whatever is necessary so that the exponent is displayed as
 stored.  This implies the exponent will fall within the IEEE format
 range, and the leading hexadecimal digit will be 0 (for denormals),
 1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
 any other digits zero).
3237*/
3238unsigned int IEEEFloat::convertToHexString(char *dst, unsigned int hexDigits,
                                         bool upperCase,
                                         roundingMode rounding_mode) const {
char *p;

p = dst;
if (sign)
  *dst++ = '-';

switch (category) {
case fcInfinity:
  memcpy (dst, upperCase ? infinityU: infinityL, sizeof infinityU - 1);
  dst += sizeof infinityL - 1;
  break;

case fcNaN:
  memcpy (dst, upperCase ? NaNU: NaNL, sizeof NaNU - 1);
  dst += sizeof NaNU - 1;
  break;

case fcZero:
  *dst++ = '0';
  *dst++ = upperCase ? 'X': 'x';
  *dst++ = '0';
  if (hexDigits > 1) {
    *dst++ = '.';
    memset (dst, '0', hexDigits - 1);
    dst += hexDigits - 1;
  }
  *dst++ = upperCase ? 'P': 'p';
  *dst++ = '0';
  break;

case fcNormal:
  dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
  break;
}

*dst = 0;

return static_cast<unsigned int>(dst - p);
3279}

3281/* Does the hard work of outputting the correctly rounded hexadecimal
 form of a normal floating point number with the specified number of
 hexadecimal digits.  If HEXDIGITS is zero the minimum number of
 digits necessary to print the value precisely is output.  */
3285char *IEEEFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
                                        bool upperCase,
                                        roundingMode rounding_mode) const {
unsigned int count, valueBits, shift, partsCount, outputDigits;
const char *hexDigitChars;
const integerPart *significand;
char *p;
bool roundUp;

*dst++ = '0';
*dst++ = upperCase ? 'X': 'x';

roundUp = false;
hexDigitChars = upperCase ? hexDigitsUpper: hexDigitsLower;

significand = significandParts();
partsCount = partCount();

/* +3 because the first digit only uses the single integer bit, so
   we have 3 virtual zero most-significant-bits.  */
valueBits = semantics->precision + 3;
shift = integerPartWidth - valueBits % integerPartWidth;

/* The natural number of digits required ignoring trailing
   insignificant zeroes.  */
outputDigits = (valueBits - significandLSB () + 3) / 4;

/* hexDigits of zero means use the required number for the
   precision.  Otherwise, see if we are truncating.  If we are,
   find out if we need to round away from zero.  */
if (hexDigits) {
  if (hexDigits < outputDigits) {
    /* We are dropping non-zero bits, so need to check how to round.
       "bits" is the number of dropped bits.  */
    unsigned int bits;
    lostFraction fraction;

    bits = valueBits - hexDigits * 4;
    fraction = lostFractionThroughTruncation (significand, partsCount, bits);
    roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
  }
  outputDigits = hexDigits;
}

/* Write the digits consecutively, and start writing in the location
   of the hexadecimal point.  We move the most significant digit
   left and add the hexadecimal point later.  */
p = ++dst;

count = (valueBits + integerPartWidth - 1) / integerPartWidth;

while (outputDigits && count) {
  integerPart part;

  /* Put the most significant integerPartWidth bits in "part".  */
  if (--count == partsCount)
    part = 0;  /* An imaginary higher zero part.  */
  else
    part = significand[count] << shift;

  if (count && shift)
    part |= significand[count - 1] >> (integerPartWidth - shift);

  /* Convert as much of "part" to hexdigits as we can.  */
  unsigned int curDigits = integerPartWidth / 4;

  if (curDigits > outputDigits)
    curDigits = outputDigits;
  dst += partAsHex (dst, part, curDigits, hexDigitChars);
  outputDigits -= curDigits;
}

if (roundUp) {
  char *q = dst;

  /* Note that hexDigitChars has a trailing '0'.  */
  do {
    q--;
    *q = hexDigitChars[hexDigitValue (*q) + 1];
  } while (*q == '0');
  assert(q >= p)(static_cast <bool> (q >= p) ? void (0) : __assert_fail
 ("q >= p", "llvm/lib/Support/APFloat.cpp", 3365, __extension__
 __PRETTY_FUNCTION__));
} else {
  /* Add trailing zeroes.  */
  memset (dst, '0', outputDigits);
  dst += outputDigits;
}

/* Move the most significant digit to before the point, and if there
   is something after the decimal point add it.  This must come
   after rounding above.  */
p[-1] = p[0];
if (dst -1 == p)
  dst--;
else
  p[0] = '.';

/* Finally output the exponent.  */
*dst++ = upperCase ? 'P': 'p';

return writeSignedDecimal (dst, exponent);
3385}

3387hash_code hash_value(const IEEEFloat &Arg) {
if (!Arg.isFiniteNonZero())
  return hash_combine((uint8_t)Arg.category,
                      // NaN has no sign, fix it at zero.
                      Arg.isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
                      Arg.semantics->precision);

// Normal floats need their exponent and significand hashed.
return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
                    Arg.semantics->precision, Arg.exponent,
                    hash_combine_range(
                      Arg.significandParts(),
                      Arg.significandParts() + Arg.partCount()));
3400}

3402// Conversion from APFloat to/from host float/double.  It may eventually be
3403// possible to eliminate these and have everybody deal with APFloats, but that
3404// will take a while.  This approach will not easily extend to long double.
3405// Current implementation requires integerPartWidth==64, which is correct at
3406// the moment but could be made more general.

3408// Denormals have exponent minExponent in APFloat, but minExponent-1 in
3409// the actual IEEE respresentations.  We compensate for that here.

3411APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt() const {
assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended)(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semX87DoubleExtended) ? void (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semX87DoubleExtended"
, "llvm/lib/Support/APFloat.cpp", 3412, __extension__ __PRETTY_FUNCTION__
));
assert(partCount()==2)(static_cast <bool> (partCount()==2) ? void (0) : __assert_fail
 ("partCount()==2", "llvm/lib/Support/APFloat.cpp", 3413, __extension__
 __PRETTY_FUNCTION__));

uint64_t myexponent, mysignificand;

if (isFiniteNonZero()) {
  myexponent = exponent+16383; //bias
  mysignificand = significandParts()[0];
  if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
    myexponent = 0;   // denormal
} else if (category==fcZero) {
  myexponent = 0;
  mysignificand = 0;
} else if (category==fcInfinity) {
  myexponent = 0x7fff;
  mysignificand = 0x8000000000000000ULL;
} else {
  assert(category == fcNaN && "Unknown category")(static_cast <bool> (category == fcNaN && "Unknown category"
) ? void (0) : __assert_fail ("category == fcNaN && \"Unknown category\""
, "llvm/lib/Support/APFloat.cpp", 3429, __extension__ __PRETTY_FUNCTION__
));
  myexponent = 0x7fff;
  mysignificand = significandParts()[0];
}

uint64_t words[2];
words[0] = mysignificand;
words[1] =  ((uint64_t)(sign & 1) << 15) |
            (myexponent & 0x7fffLL);
return APInt(80, words);
3439}

3441APInt IEEEFloat::convertPPCDoubleDoubleAPFloatToAPInt() const {
assert(semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy)(static_cast <bool> (semantics == (const llvm::fltSemantics
 *)&semPPCDoubleDoubleLegacy) ? void (0) : __assert_fail (
"semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy"
, "llvm/lib/Support/APFloat.cpp", 3442, __extension__ __PRETTY_FUNCTION__
));
assert(partCount()==2)(static_cast <bool> (partCount()==2) ? void (0) : __assert_fail
 ("partCount()==2", "llvm/lib/Support/APFloat.cpp", 3443, __extension__
 __PRETTY_FUNCTION__));

uint64_t words[2];
opStatus fs;
bool losesInfo;

// Convert number to double.  To avoid spurious underflows, we re-
// normalize against the "double" minExponent first, and only *then*
// truncate the mantissa.  The result of that second conversion
// may be inexact, but should never underflow.
// Declare fltSemantics before APFloat that uses it (and
// saves pointer to it) to ensure correct destruction order.
fltSemantics extendedSemantics = *semantics;
extendedSemantics.minExponent = semIEEEdouble.minExponent;
IEEEFloat extended(*this);
fs = extended.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 3459, __extension__ __PRETTY_FUNCTION__
));
(void)fs;

IEEEFloat u(extended);
fs = u.convert(semIEEEdouble, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK || fs == opInexact)(static_cast <bool> (fs == opOK || fs == opInexact) ? void
 (0) : __assert_fail ("fs == opOK || fs == opInexact", "llvm/lib/Support/APFloat.cpp"
, 3464, __extension__ __PRETTY_FUNCTION__));
(void)fs;
words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();

// If conversion was exact or resulted in a special case, we're done;
// just set the second double to zero.  Otherwise, re-convert back to
// the extended format and compute the difference.  This now should
// convert exactly to double.
if (u.isFiniteNonZero() && losesInfo) {
  fs = u.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
  assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 3474, __extension__ __PRETTY_FUNCTION__
));
  (void)fs;

  IEEEFloat v(extended);
  v.subtract(u, rmNearestTiesToEven);
  fs = v.convert(semIEEEdouble, rmNearestTiesToEven, &losesInfo);
  assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 3480, __extension__ __PRETTY_FUNCTION__
));
  (void)fs;
  words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
} else {
  words[1] = 0;
}

return APInt(128, words);
3488}

3490template <const fltSemantics &S>
3491APInt IEEEFloat::convertIEEEFloatToAPInt() const {
assert(semantics == &S)(static_cast <bool> (semantics == &S) ? void (0) : __assert_fail
 ("semantics == &S", "llvm/lib/Support/APFloat.cpp", 3492
, __extension__ __PRETTY_FUNCTION__));

constexpr int bias = -(S.minExponent - 1);
constexpr unsigned int trailing_significand_bits = S.precision - 1;
constexpr int integer_bit_part = trailing_significand_bits / integerPartWidth;
constexpr integerPart integer_bit =
    integerPart{1} << (trailing_significand_bits % integerPartWidth);
constexpr uint64_t significand_mask = integer_bit - 1;
constexpr unsigned int exponent_bits =
    S.sizeInBits - 1 - trailing_significand_bits;
static_assert(exponent_bits < 64);
constexpr uint64_t exponent_mask = (uint64_t{1} << exponent_bits) - 1;

uint64_t myexponent;
std::array<integerPart, partCountForBits(trailing_significand_bits)>
    mysignificand;

if (isFiniteNonZero()) {
  myexponent = exponent + bias;
  std::copy_n(significandParts(), mysignificand.size(),
              mysignificand.begin());
  if (myexponent == 1 &&
      !(significandParts()[integer_bit_part] & integer_bit))
    myexponent = 0; // denormal
} else if (category == fcZero) {
  myexponent = ::exponentZero(S) + bias;
  mysignificand.fill(0);
} else if (category == fcInfinity) {
  if (S.nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
    llvm_unreachable("semantics don't support inf!")::llvm::llvm_unreachable_internal("semantics don't support inf!"
, "llvm/lib/Support/APFloat.cpp", 3521);
  }
  myexponent = ::exponentInf(S) + bias;
  mysignificand.fill(0);
} else {
  assert(category == fcNaN && "Unknown category!")(static_cast <bool> (category == fcNaN && "Unknown category!"
) ? void (0) : __assert_fail ("category == fcNaN && \"Unknown category!\""
, "llvm/lib/Support/APFloat.cpp", 3526, __extension__ __PRETTY_FUNCTION__
));
  myexponent = ::exponentNaN(S) + bias;
  std::copy_n(significandParts(), mysignificand.size(),
              mysignificand.begin());
}
std::array<uint64_t, (S.sizeInBits + 63) / 64> words;
auto words_iter =
    std::copy_n(mysignificand.begin(), mysignificand.size(), words.begin());
if constexpr (significand_mask != 0) {
  // Clear the integer bit.
  words[mysignificand.size() - 1] &= significand_mask;
}
std::fill(words_iter, words.end(), uint64_t{0});
constexpr size_t last_word = words.size() - 1;
uint64_t shifted_sign = static_cast<uint64_t>(sign & 1)
                        << ((S.sizeInBits - 1) % 64);
words[last_word] |= shifted_sign;
uint64_t shifted_exponent = (myexponent & exponent_mask)
                            << (trailing_significand_bits % 64);
words[last_word] |= shifted_exponent;
if constexpr (last_word == 0) {
  return APInt(S.sizeInBits, words[0]);
}
return APInt(S.sizeInBits, words);
3550}

3552APInt IEEEFloat::convertQuadrupleAPFloatToAPInt() const {
assert(partCount() == 2)(static_cast <bool> (partCount() == 2) ? void (0) : __assert_fail
 ("partCount() == 2", "llvm/lib/Support/APFloat.cpp", 3553, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semIEEEquad>();
3555}

3557APInt IEEEFloat::convertDoubleAPFloatToAPInt() const {
assert(partCount()==1)(static_cast <bool> (partCount()==1) ? void (0) : __assert_fail
 ("partCount()==1", "llvm/lib/Support/APFloat.cpp", 3558, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semIEEEdouble>();
3560}

3562APInt IEEEFloat::convertFloatAPFloatToAPInt() const {
assert(partCount()==1)(static_cast <bool> (partCount()==1) ? void (0) : __assert_fail
 ("partCount()==1", "llvm/lib/Support/APFloat.cpp", 3563, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semIEEEsingle>();
3565}

3567APInt IEEEFloat::convertBFloatAPFloatToAPInt() const {
assert(partCount() == 1)(static_cast <bool> (partCount() == 1) ? void (0) : __assert_fail
 ("partCount() == 1", "llvm/lib/Support/APFloat.cpp", 3568, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semBFloat>();
3570}

3572APInt IEEEFloat::convertHalfAPFloatToAPInt() const {
assert(partCount()==1)(static_cast <bool> (partCount()==1) ? void (0) : __assert_fail
 ("partCount()==1", "llvm/lib/Support/APFloat.cpp", 3573, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semIEEEhalf>();
3575}

3577APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt() const {
assert(partCount() == 1)(static_cast <bool> (partCount() == 1) ? void (0) : __assert_fail
 ("partCount() == 1", "llvm/lib/Support/APFloat.cpp", 3578, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semFloat8E5M2>();
3580}

3582APInt IEEEFloat::convertFloat8E5M2FNUZAPFloatToAPInt() const {
assert(partCount() == 1)(static_cast <bool> (partCount() == 1) ? void (0) : __assert_fail
 ("partCount() == 1", "llvm/lib/Support/APFloat.cpp", 3583, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semFloat8E5M2FNUZ>();
3585}

3587APInt IEEEFloat::convertFloat8E4M3FNAPFloatToAPInt() const {
assert(partCount() == 1)(static_cast <bool> (partCount() == 1) ? void (0) : __assert_fail
 ("partCount() == 1", "llvm/lib/Support/APFloat.cpp", 3588, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semFloat8E4M3FN>();
3590}

3592APInt IEEEFloat::convertFloat8E4M3FNUZAPFloatToAPInt() const {
assert(partCount() == 1)(static_cast <bool> (partCount() == 1) ? void (0) : __assert_fail
 ("partCount() == 1", "llvm/lib/Support/APFloat.cpp", 3593, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semFloat8E4M3FNUZ>();
3595}

3597APInt IEEEFloat::convertFloat8E4M3B11FNUZAPFloatToAPInt() const {
assert(partCount() == 1)(static_cast <bool> (partCount() == 1) ? void (0) : __assert_fail
 ("partCount() == 1", "llvm/lib/Support/APFloat.cpp", 3598, __extension__
 __PRETTY_FUNCTION__));
return convertIEEEFloatToAPInt<semFloat8E4M3B11FNUZ>();
3600}

3602// This function creates an APInt that is just a bit map of the floating
3603// point constant as it would appear in memory.  It is not a conversion,
3604// and treating the result as a normal integer is unlikely to be useful.

3606APInt IEEEFloat::bitcastToAPInt() const {
if (semantics == (const llvm::fltSemantics*)&semIEEEhalf)
  return convertHalfAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semBFloat)
  return convertBFloatAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics*)&semIEEEsingle)
  return convertFloatAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics*)&semIEEEdouble)
  return convertDoubleAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics*)&semIEEEquad)
  return convertQuadrupleAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy)
  return convertPPCDoubleDoubleAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2)
  return convertFloat8E5M2APFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semFloat8E5M2FNUZ)
  return convertFloat8E5M2FNUZAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FN)
  return convertFloat8E4M3FNAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3FNUZ)
  return convertFloat8E4M3FNUZAPFloatToAPInt();

if (semantics == (const llvm::fltSemantics *)&semFloat8E4M3B11FNUZ)
  return convertFloat8E4M3B11FNUZAPFloatToAPInt();

assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended &&(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semX87DoubleExtended && "unknown format!") ? void
 (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semX87DoubleExtended && \"unknown format!\""
, "llvm/lib/Support/APFloat.cpp", 3641, __extension__ __PRETTY_FUNCTION__
))
       "unknown format!")(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semX87DoubleExtended && "unknown format!") ? void
 (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semX87DoubleExtended && \"unknown format!\""
, "llvm/lib/Support/APFloat.cpp", 3641, __extension__ __PRETTY_FUNCTION__
));
return convertF80LongDoubleAPFloatToAPInt();
3643}

3645float IEEEFloat::convertToFloat() const {
assert(semantics == (const llvm::fltSemantics*)&semIEEEsingle &&(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semIEEEsingle && "Float semantics are not IEEEsingle"
) ? void (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semIEEEsingle && \"Float semantics are not IEEEsingle\""
, "llvm/lib/Support/APFloat.cpp", 3647, __extension__ __PRETTY_FUNCTION__
))
       "Float semantics are not IEEEsingle")(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semIEEEsingle && "Float semantics are not IEEEsingle"
) ? void (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semIEEEsingle && \"Float semantics are not IEEEsingle\""
, "llvm/lib/Support/APFloat.cpp", 3647, __extension__ __PRETTY_FUNCTION__
));
APInt api = bitcastToAPInt();
return api.bitsToFloat();
3650}

3652double IEEEFloat::convertToDouble() const {
assert(semantics == (const llvm::fltSemantics*)&semIEEEdouble &&(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semIEEEdouble && "Float semantics are not IEEEdouble"
) ? void (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semIEEEdouble && \"Float semantics are not IEEEdouble\""
, "llvm/lib/Support/APFloat.cpp", 3654, __extension__ __PRETTY_FUNCTION__
))
       "Float semantics are not IEEEdouble")(static_cast <bool> (semantics == (const llvm::fltSemantics
*)&semIEEEdouble && "Float semantics are not IEEEdouble"
) ? void (0) : __assert_fail ("semantics == (const llvm::fltSemantics*)&semIEEEdouble && \"Float semantics are not IEEEdouble\""
, "llvm/lib/Support/APFloat.cpp", 3654, __extension__ __PRETTY_FUNCTION__
));
APInt api = bitcastToAPInt();
return api.bitsToDouble();
3657}

3659/// Integer bit is explicit in this format.  Intel hardware (387 and later)
3660/// does not support these bit patterns:
3661///  exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
3662///  exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
3663///  exponent!=0 nor all 1's, integer bit 0 ("unnormal")
3664///  exponent = 0, integer bit 1 ("pseudodenormal")
3665/// At the moment, the first three are treated as NaNs, the last one as Normal.
3666void IEEEFloat::initFromF80LongDoubleAPInt(const APInt &api) {
uint64_t i1 = api.getRawData()[0];
uint64_t i2 = api.getRawData()[1];
uint64_t myexponent = (i2 & 0x7fff);
uint64_t mysignificand = i1;
uint8_t myintegerbit = mysignificand >> 63;

initialize(&semX87DoubleExtended);
assert(partCount()==2)(static_cast <bool> (partCount()==2) ? void (0) : __assert_fail
 ("partCount()==2", "llvm/lib/Support/APFloat.cpp", 3674, __extension__
 __PRETTY_FUNCTION__));

sign = static_cast<unsigned int>(i2>>15);
if (myexponent == 0 && mysignificand == 0) {
  makeZero(sign);
} else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
  makeInf(sign);
} else if ((myexponent == 0x7fff && mysignificand != 0x8000000000000000ULL) ||
           (myexponent != 0x7fff && myexponent != 0 && myintegerbit == 0)) {
  category = fcNaN;
  exponent = exponentNaN();
  significandParts()[0] = mysignificand;
  significandParts()[1] = 0;
} else {
  category = fcNormal;
  exponent = myexponent - 16383;
  significandParts()[0] = mysignificand;
  significandParts()[1] = 0;
  if (myexponent==0)          // denormal
    exponent = -16382;
}
3695}

3697void IEEEFloat::initFromPPCDoubleDoubleAPInt(const APInt &api) {
uint64_t i1 = api.getRawData()[0];
uint64_t i2 = api.getRawData()[1];
opStatus fs;
bool losesInfo;

// Get the first double and convert to our format.
initFromDoubleAPInt(APInt(64, i1));
fs = convert(semPPCDoubleDoubleLegacy, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 3706, __extension__ __PRETTY_FUNCTION__
));
(void)fs;

// Unless we have a special case, add in second double.
if (isFiniteNonZero()) {
  IEEEFloat v(semIEEEdouble, APInt(64, i2));
  fs = v.convert(semPPCDoubleDoubleLegacy, rmNearestTiesToEven, &losesInfo);
  assert(fs == opOK && !losesInfo)(static_cast <bool> (fs == opOK && !losesInfo) ?
 void (0) : __assert_fail ("fs == opOK && !losesInfo"
, "llvm/lib/Support/APFloat.cpp", 3713, __extension__ __PRETTY_FUNCTION__
));
  (void)fs;

  add(v, rmNearestTiesToEven);
}
3718}

3720template <const fltSemantics &S>
3721void IEEEFloat::initFromIEEEAPInt(const APInt &api) {
assert(api.getBitWidth() == S.sizeInBits)(static_cast <bool> (api.getBitWidth() == S.sizeInBits)
 ? void (0) : __assert_fail ("api.getBitWidth() == S.sizeInBits"
, "llvm/lib/Support/APFloat.cpp", 3722, __extension__ __PRETTY_FUNCTION__
));
constexpr integerPart integer_bit = integerPart{1}
                                    << ((S.precision - 1) % integerPartWidth);
constexpr uint64_t significand_mask = integer_bit - 1;
constexpr unsigned int trailing_significand_bits = S.precision - 1;
constexpr unsigned int stored_significand_parts =
    partCountForBits(trailing_significand_bits);
constexpr unsigned int exponent_bits =
    S.sizeInBits - 1 - trailing_significand_bits;
static_assert(exponent_bits < 64);
constexpr uint64_t exponent_mask = (uint64_t{1} << exponent_bits) - 1;
constexpr int bias = -(S.minExponent - 1);

// Copy the bits of the significand. We need to clear out the exponent and
// sign bit in the last word.
std::array<integerPart, stored_significand_parts> mysignificand;
std::copy_n(api.getRawData(), mysignificand.size(), mysignificand.begin());
if constexpr (significand_mask != 0) {
  mysignificand[mysignificand.size() - 1] &= significand_mask;
}

// We assume the last word holds the sign bit, the exponent, and potentially
// some of the trailing significand field.
uint64_t last_word = api.getRawData()[api.getNumWords() - 1];
uint64_t myexponent =
    (last_word >> (trailing_significand_bits % 64)) & exponent_mask;

initialize(&S);
assert(partCount() == mysignificand.size())(static_cast <bool> (partCount() == mysignificand.size(
)) ? void (0) : __assert_fail ("partCount() == mysignificand.size()"
, "llvm/lib/Support/APFloat.cpp", 3750, __extension__ __PRETTY_FUNCTION__
));

sign = static_cast<unsigned int>(last_word >> ((S.sizeInBits - 1) % 64));

bool all_zero_significand =
    llvm::all_of(mysignificand, [](integerPart bits) { return bits == 0; });

bool is_zero = myexponent == 0 && all_zero_significand;

if constexpr (S.nonFiniteBehavior == fltNonfiniteBehavior::IEEE754) {
  if (myexponent - bias == ::exponentInf(S) && all_zero_significand) {
    makeInf(sign);
    return;
  }
}

bool is_nan = false;

if constexpr (S.nanEncoding == fltNanEncoding::IEEE) {
  is_nan = myexponent - bias == ::exponentNaN(S) && !all_zero_significand;
} else if constexpr (S.nanEncoding == fltNanEncoding::AllOnes) {
  bool all_ones_significand =
      std::all_of(mysignificand.begin(), mysignificand.end() - 1,
                  [](integerPart bits) { return bits == ~integerPart{0}; }) &&
      (!significand_mask ||
       mysignificand[mysignificand.size() - 1] == significand_mask);
  is_nan = myexponent - bias == ::exponentNaN(S) && all_ones_significand;
} else if constexpr (S.nanEncoding == fltNanEncoding::NegativeZero) {
  is_nan = is_zero && sign;
}

if (is_nan) {
  category = fcNaN;
  exponent = ::exponentNaN(S);
  std::copy_n(mysignificand.begin(), mysignificand.size(),
              significandParts());
  return;
}

if (is_zero) {
  makeZero(sign);
  return;
}

category = fcNormal;
exponent = myexponent - bias;
std::copy_n(mysignificand.begin(), mysignificand.size(), significandParts());
if (myexponent == 0) // denormal
  exponent = S.minExponent;
else
  significandParts()[mysignificand.size()-1] |= integer_bit; // integer bit
3801}

3803void IEEEFloat::initFromQuadrupleAPInt(const APInt &api) {
initFromIEEEAPInt<semIEEEquad>(api);
3805}

3807void IEEEFloat::initFromDoubleAPInt(const APInt &api) {
initFromIEEEAPInt<semIEEEdouble>(api);
3809}

3811void IEEEFloat::initFromFloatAPInt(const APInt &api) {
initFromIEEEAPInt<semIEEEsingle>(api);
3813}

3815void IEEEFloat::initFromBFloatAPInt(const APInt &api) {
initFromIEEEAPInt<semBFloat>(api);
3817}

3819void IEEEFloat::initFromHalfAPInt(const APInt &api) {
initFromIEEEAPInt<semIEEEhalf>(api);
3821}

3823void IEEEFloat::initFromFloat8E5M2APInt(const APInt &api) {
initFromIEEEAPInt<semFloat8E5M2>(api);
3825}

3827void IEEEFloat::initFromFloat8E5M2FNUZAPInt(const APInt &api) {
initFromIEEEAPInt<semFloat8E5M2FNUZ>(api);
3829}

3831void IEEEFloat::initFromFloat8E4M3FNAPInt(const APInt &api) {
initFromIEEEAPInt<semFloat8E4M3FN>(api);
3833}

3835void IEEEFloat::initFromFloat8E4M3FNUZAPInt(const APInt &api) {
initFromIEEEAPInt<semFloat8E4M3FNUZ>(api);
3837}

3839void IEEEFloat::initFromFloat8E4M3B11FNUZAPInt(const APInt &api) {
initFromIEEEAPInt<semFloat8E4M3B11FNUZ>(api);
3841}

3843/// Treat api as containing the bits of a floating point number.
3844void IEEEFloat::initFromAPInt(const fltSemantics *Sem, const APInt &api) {
assert(api.getBitWidth() == Sem->sizeInBits)(static_cast <bool> (api.getBitWidth() == Sem->sizeInBits
) ? void (0) : __assert_fail ("api.getBitWidth() == Sem->sizeInBits"
, "llvm/lib/Support/APFloat.cpp", 3845, __extension__ __PRETTY_FUNCTION__
));
if (Sem == &semIEEEhalf)
  return initFromHalfAPInt(api);
if (Sem == &semBFloat)
  return initFromBFloatAPInt(api);
if (Sem == &semIEEEsingle)
  return initFromFloatAPInt(api);
if (Sem == &semIEEEdouble)
  return initFromDoubleAPInt(api);
if (Sem == &semX87DoubleExtended)
  return initFromF80LongDoubleAPInt(api);
if (Sem == &semIEEEquad)
  return initFromQuadrupleAPInt(api);
if (Sem == &semPPCDoubleDoubleLegacy)
  return initFromPPCDoubleDoubleAPInt(api);
if (Sem == &semFloat8E5M2)
  return initFromFloat8E5M2APInt(api);
if (Sem == &semFloat8E5M2FNUZ)
  return initFromFloat8E5M2FNUZAPInt(api);
if (Sem == &semFloat8E4M3FN)
  return initFromFloat8E4M3FNAPInt(api);
if (Sem == &semFloat8E4M3FNUZ)
  return initFromFloat8E4M3FNUZAPInt(api);
if (Sem == &semFloat8E4M3B11FNUZ)
  return initFromFloat8E4M3B11FNUZAPInt(api);

llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "llvm/lib/Support/APFloat.cpp"
, 3871);
3872}

3874/// Make this number the largest magnitude normal number in the given
3875/// semantics.
3876void IEEEFloat::makeLargest(bool Negative) {
// We want (in interchange format):
//   sign = {Negative}
//   exponent = 1..10
//   significand = 1..1
category = fcNormal;
sign = Negative;
exponent = semantics->maxExponent;

// Use memset to set all but the highest integerPart to all ones.
integerPart *significand = significandParts();
unsigned PartCount = partCount();
memset(significand, 0xFF, sizeof(integerPart)*(PartCount - 1));

// Set the high integerPart especially setting all unused top bits for
// internal consistency.
const unsigned NumUnusedHighBits =
  PartCount*integerPartWidth - semantics->precision;
significand[PartCount - 1] = (NumUnusedHighBits < integerPartWidth)
                                 ? (~integerPart(0) >> NumUnusedHighBits)
                                 : 0;

if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly &&
    semantics->nanEncoding == fltNanEncoding::AllOnes)
  significand[0] &= ~integerPart(1);
3901}

3903/// Make this number the smallest magnitude denormal number in the given
3904/// semantics.
3905void IEEEFloat::makeSmallest(bool Negative) {
// We want (in interchange format):
//   sign = {Negative}
//   exponent = 0..0
//   significand = 0..01
category = fcNormal;
sign = Negative;
exponent = semantics->minExponent;
APInt::tcSet(significandParts(), 1, partCount());
3914}

3916void IEEEFloat::makeSmallestNormalized(bool Negative) {
// We want (in interchange format):
//   sign = {Negative}
//   exponent = 0..0
//   significand = 10..0

category = fcNormal;
zeroSignificand();
sign = Negative;
exponent = semantics->minExponent;
APInt::tcSetBit(significandParts(), semantics->precision - 1);
3927}

3929IEEEFloat::IEEEFloat(const fltSemantics &Sem, const APInt &API) {
initFromAPInt(&Sem, API);
3931}

3933IEEEFloat::IEEEFloat(float f) {
initFromAPInt(&semIEEEsingle, APInt::floatToBits(f));
3935}

3937IEEEFloat::IEEEFloat(double d) {
initFromAPInt(&semIEEEdouble, APInt::doubleToBits(d));
3939}

3941namespace {
void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
  Buffer.append(Str.begin(), Str.end());
}

/// Removes data from the given significand until it is no more
/// precise than is required for the desired precision.
void AdjustToPrecision(APInt &significand,
                       int &exp, unsigned FormatPrecision) {
  unsigned bits = significand.getActiveBits();

  // 196/59 is a very slight overestimate of lg_2(10).
  unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;

  if (bits <= bitsRequired) return;

  unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
  if (!tensRemovable) return;

  exp += tensRemovable;

  APInt divisor(significand.getBitWidth(), 1);
  APInt powten(significand.getBitWidth(), 10);
  while (true) {
    if (tensRemovable & 1)
      divisor *= powten;
    tensRemovable >>= 1;
    if (!tensRemovable) break;
    powten *= powten;
  }

  significand = significand.udiv(divisor);

  // Truncate the significand down to its active bit count.
  significand = significand.trunc(significand.getActiveBits());
}


void AdjustToPrecision(SmallVectorImpl<char> &buffer,
                       int &exp, unsigned FormatPrecision) {
  unsigned N = buffer.size();
  if (N <= FormatPrecision) return;

  // The most significant figures are the last ones in the buffer.
  unsigned FirstSignificant = N - FormatPrecision;

  // Round.
  // FIXME: this probably shouldn't use 'round half up'.

  // Rounding down is just a truncation, except we also want to drop
  // trailing zeros from the new result.
  if (buffer[FirstSignificant - 1] < '5') {
    while (FirstSignificant < N && buffer[FirstSignificant] == '0')
      FirstSignificant++;

    exp += FirstSignificant;
    buffer.erase(&buffer[0], &buffer[FirstSignificant]);
    return;
  }

  // Rounding up requires a decimal add-with-carry.  If we continue
  // the carry, the newly-introduced zeros will just be truncated.
  for (unsigned I = FirstSignificant; I != N; ++I) {
    if (buffer[I] == '9') {
      FirstSignificant++;
    } else {
      buffer[I]++;
      break;
    }
  }

  // If we carried through, we have exactly one digit of precision.
  if (FirstSignificant == N) {
    exp += FirstSignificant;
    buffer.clear();
    buffer.push_back('1');
    return;
  }

  exp += FirstSignificant;
  buffer.erase(&buffer[0], &buffer[FirstSignificant]);
}
4023} // namespace

4025void IEEEFloat::toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
                       unsigned FormatMaxPadding, bool TruncateZero) const {
switch (category) {
case fcInfinity:
  if (isNegative())
    return append(Str, "-Inf");
  else
    return append(Str, "+Inf");

case fcNaN: return append(Str, "NaN");

case fcZero:
  if (isNegative())
    Str.push_back('-');

  if (!FormatMaxPadding) {
    if (TruncateZero)
      append(Str, "0.0E+0");
    else {
      append(Str, "0.0");
      if (FormatPrecision > 1)
        Str.append(FormatPrecision - 1, '0');
      append(Str, "e+00");
    }
  } else
    Str.push_back('0');
  return;

case fcNormal:
  break;
}

if (isNegative())
  Str.push_back('-');

// Decompose the number into an APInt and an exponent.
int exp = exponent - ((int) semantics->precision - 1);
APInt significand(
    semantics->precision,
    ArrayRef(significandParts(), partCountForBits(semantics->precision)));

// Set FormatPrecision if zero.  We want to do this before we
// truncate trailing zeros, as those are part of the precision.
if (!FormatPrecision) {
  // We use enough digits so the number can be round-tripped back to an
  // APFloat. The formula comes from "How to Print Floating-Point Numbers
  // Accurately" by Steele and White.
  // FIXME: Using a formula based purely on the precision is conservative;
  // we can print fewer digits depending on the actual value being printed.

  // FormatPrecision = 2 + floor(significandBits / lg_2(10))
  FormatPrecision = 2 + semantics->precision * 59 / 196;
}

// Ignore trailing binary zeros.
int trailingZeros = significand.countr_zero();
exp += trailingZeros;
significand.lshrInPlace(trailingZeros);

// Change the exponent from 2^e to 10^e.
if (exp == 0) {
  // Nothing to do.
} else if (exp > 0) {
  // Just shift left.
  significand = significand.zext(semantics->precision + exp);
  significand <<= exp;
  exp = 0;
} else { /* exp < 0 */
  int texp = -exp;

  // We transform this using the identity:
  //   (N)(2^-e) == (N)(5^e)(10^-e)
  // This means we have to multiply N (the significand) by 5^e.
  // To avoid overflow, we have to operate on numbers large
  // enough to store N * 5^e:
  //   log2(N * 5^e) == log2(N) + e * log2(5)
  //                 <= semantics->precision + e * 137 / 59
  //   (log_2(5) ~ 2.321928 < 2.322034 ~ 137/59)

  unsigned precision = semantics->precision + (137 * texp + 136) / 59;

  // Multiply significand by 5^e.
  //   N * 5^0101 == N * 5^(1*1) * 5^(0*2) * 5^(1*4) * 5^(0*8)
  significand = significand.zext(precision);
  APInt five_to_the_i(precision, 5);
  while (true) {
    if (texp & 1) significand *= five_to_the_i;

    texp >>= 1;
    if (!texp) break;
    five_to_the_i *= five_to_the_i;
  }
}

AdjustToPrecision(significand, exp, FormatPrecision);

SmallVector<char, 256> buffer;

// Fill the buffer.
unsigned precision = significand.getBitWidth();
if (precision < 4) {
  // We need enough precision to store the value 10.
  precision = 4;
  significand = significand.zext(precision);
}
APInt ten(precision, 10);
APInt digit(precision, 0);

bool inTrail = true;
while (significand != 0) {
  // digit <- significand % 10
  // significand <- significand / 10
  APInt::udivrem(significand, ten, significand, digit);

  unsigned d = digit.getZExtValue();

  // Drop trailing zeros.
  if (inTrail && !d) exp++;
  else {
    buffer.push_back((char) ('0' + d));
    inTrail = false;
  }
}

assert(!buffer.empty() && "no characters in buffer!")(static_cast <bool> (!buffer.empty() && "no characters in buffer!"
) ? void (0) : __assert_fail ("!buffer.empty() && \"no characters in buffer!\""
, "llvm/lib/Support/APFloat.cpp", 4149, __extension__ __PRETTY_FUNCTION__
));

// Drop down to FormatPrecision.
// TODO: don't do more precise calculations above than are required.
AdjustToPrecision(buffer, exp, FormatPrecision);

unsigned NDigits = buffer.size();

// Check whether we should use scientific notation.
bool FormatScientific;
if (!FormatMaxPadding)
  FormatScientific = true;
else {
  if (exp >= 0) {
    // 765e3 --> 765000
    //              ^^^
    // But we shouldn't make the number look more precise than it is.
    FormatScientific = ((unsigned) exp > FormatMaxPadding ||
                        NDigits + (unsigned) exp > FormatPrecision);
  } else {
    // Power of the most significant digit.
    int MSD = exp + (int) (NDigits - 1);
    if (MSD >= 0) {
      // 765e-2 == 7.65
      FormatScientific = false;
    } else {
      // 765e-5 == 0.00765
      //           ^ ^^
      FormatScientific = ((unsigned) -MSD) > FormatMaxPadding;
    }
  }
}

// Scientific formatting is pretty straightforward.
if (FormatScientific) {
  exp += (NDigits - 1);

  Str.push_back(buffer[NDigits-1]);
  Str.push_back('.');
  if (NDigits == 1 && TruncateZero)
    Str.push_back('0');
  else
    for (unsigned I = 1; I != NDigits; ++I)
      Str.push_back(buffer[NDigits-1-I]);
  // Fill with zeros up to FormatPrecision.
  if (!TruncateZero && FormatPrecision > NDigits - 1)
    Str.append(FormatPrecision - NDigits + 1, '0');
  // For !TruncateZero we use lower 'e'.
  Str.push_back(TruncateZero ? 'E' : 'e');

  Str.push_back(exp >= 0 ? '+' : '-');
  if (exp < 0) exp = -exp;
  SmallVector<char, 6> expbuf;
  do {
    expbuf.push_back((char) ('0' + (exp % 10)));
    exp /= 10;
  } while (exp);
  // Exponent always at least two digits if we do not truncate zeros.
  if (!TruncateZero && expbuf.size() < 2)
    expbuf.push_back('0');
  for (unsigned I = 0, E = expbuf.size(); I != E; ++I)
    Str.push_back(expbuf[E-1-I]);
  return;
}

// Non-scientific, positive exponents.
if (exp >= 0) {
  for (unsigned I = 0; I != NDigits; ++I)
    Str.push_back(buffer[NDigits-1-I]);
  for (unsigned I = 0; I != (unsigned) exp; ++I)
    Str.push_back('0');
  return;
}

// Non-scientific, negative exponents.

// The number of digits to the left of the decimal point.
int NWholeDigits = exp + (int) NDigits;

unsigned I = 0;
if (NWholeDigits > 0) {
  for (; I != (unsigned) NWholeDigits; ++I)
    Str.push_back(buffer[NDigits-I-1]);
  Str.push_back('.');
} else {
  unsigned NZeros = 1 + (unsigned) -NWholeDigits;

  Str.push_back('0');
  Str.push_back('.');
  for (unsigned Z = 1; Z != NZeros; ++Z)
    Str.push_back('0');
}

for (; I != NDigits; ++I)
  Str.push_back(buffer[NDigits-I-1]);
4244}

4246bool IEEEFloat::getExactInverse(APFloat *inv) const {
// Special floats and denormals have no exact inverse.
if (!isFiniteNonZero())
  return false;

// Check that the number is a power of two by making sure that only the
// integer bit is set in the significand.
if (significandLSB() != semantics->precision - 1)
  return false;

// Get the inverse.
IEEEFloat reciprocal(*semantics, 1ULL);
if (reciprocal.divide(*this, rmNearestTiesToEven) != opOK)
  return false;

// Avoid multiplication with a denormal, it is not safe on all platforms and
// may be slower than a normal division.
if (reciprocal.isDenormal())
  return false;

assert(reciprocal.isFiniteNonZero() &&(static_cast <bool> (reciprocal.isFiniteNonZero() &&
 reciprocal.significandLSB() == reciprocal.semantics->precision
 - 1) ? void (0) : __assert_fail ("reciprocal.isFiniteNonZero() && reciprocal.significandLSB() == reciprocal.semantics->precision - 1"
, "llvm/lib/Support/APFloat.cpp", 4267, __extension__ __PRETTY_FUNCTION__
))
       reciprocal.significandLSB() == reciprocal.semantics->precision - 1)(static_cast <bool> (reciprocal.isFiniteNonZero() &&
 reciprocal.significandLSB() == reciprocal.semantics->precision
 - 1) ? void (0) : __assert_fail ("reciprocal.isFiniteNonZero() && reciprocal.significandLSB() == reciprocal.semantics->precision - 1"
, "llvm/lib/Support/APFloat.cpp", 4267, __extension__ __PRETTY_FUNCTION__
));

if (inv)
  *inv = APFloat(reciprocal, *semantics);

return true;
4273}

4275bool IEEEFloat::isSignaling() const {
if (!isNaN())
  return false;
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
  return false;

// IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
// first bit of the trailing significand being 0.
return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
4284}

4286/// IEEE-754R 2008 5.3.1: nextUp/nextDown.
4287///
4288/// *NOTE* since nextDown(x) = -nextUp(-x), we only implement nextUp with
4289/// appropriate sign switching before/after the computation.
4290IEEEFloat::opStatus IEEEFloat::next(bool nextDown) {
// If we are performing nextDown, swap sign so we have -x.
if (nextDown)
  changeSign();

// Compute nextUp(x)
opStatus result = opOK;

// Handle each float category separately.
switch (category) {
case fcInfinity:
  // nextUp(+inf) = +inf
  if (!isNegative())
    break;
  // nextUp(-inf) = -getLargest()
  makeLargest(true);
  break;
case fcNaN:
  // IEEE-754R 2008 6.2 Par 2: nextUp(sNaN) = qNaN. Set Invalid flag.
  // IEEE-754R 2008 6.2: nextUp(qNaN) = qNaN. Must be identity so we do not
  //                     change the payload.
  if (isSignaling()) {
    result = opInvalidOp;
    // For consistency, propagate the sign of the sNaN to the qNaN.
    makeNaN(false, isNegative(), nullptr);
  }
  break;
case fcZero:
  // nextUp(pm 0) = +getSmallest()
  makeSmallest(false);
  break;
case fcNormal:
  // nextUp(-getSmallest()) = -0
  if (isSmallest() && isNegative()) {
    APInt::tcSet(significandParts(), 0, partCount());
    category = fcZero;
    exponent = 0;
    if (semantics->nanEncoding == fltNanEncoding::NegativeZero)
      sign = false;
    break;
  }

  if (isLargest() && !isNegative()) {
    if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
      // nextUp(getLargest()) == NAN
      makeNaN();
      break;
    } else {
      // nextUp(getLargest()) == INFINITY
      APInt::tcSet(significandParts(), 0, partCount());
      category = fcInfinity;
      exponent = semantics->maxExponent + 1;
      break;
    }
  }

  // nextUp(normal) == normal + inc.
  if (isNegative()) {
    // If we are negative, we need to decrement the significand.

    // We only cross a binade boundary that requires adjusting the exponent
    // if:
    //   1. exponent != semantics->minExponent. This implies we are not in the
    //   smallest binade or are dealing with denormals.
    //   2. Our significand excluding the integral bit is all zeros.
    bool WillCrossBinadeBoundary =
      exponent != semantics->minExponent && isSignificandAllZeros();

    // Decrement the significand.
    //
    // We always do this since:
    //   1. If we are dealing with a non-binade decrement, by definition we
    //   just decrement the significand.
    //   2. If we are dealing with a normal -> normal binade decrement, since
    //   we have an explicit integral bit the fact that all bits but the
    //   integral bit are zero implies that subtracting one will yield a
    //   significand with 0 integral bit and 1 in all other spots. Thus we
    //   must just adjust the exponent and set the integral bit to 1.
    //   3. If we are dealing with a normal -> denormal binade decrement,
    //   since we set the integral bit to 0 when we represent denormals, we
    //   just decrement the significand.
    integerPart *Parts = significandParts();
    APInt::tcDecrement(Parts, partCount());

    if (WillCrossBinadeBoundary) {
      // Our result is a normal number. Do the following:
      // 1. Set the integral bit to 1.
      // 2. Decrement the exponent.
      APInt::tcSetBit(Parts, semantics->precision - 1);
      exponent--;
    }
  } else {
    // If we are positive, we need to increment the significand.

    // We only cross a binade boundary that requires adjusting the exponent if
    // the input is not a denormal and all of said input's significand bits
    // are set. If all of said conditions are true: clear the significand, set
    // the integral bit to 1, and increment the exponent. If we have a
    // denormal always increment since moving denormals and the numbers in the
    // smallest normal binade have the same exponent in our representation.
    bool WillCrossBinadeBoundary = !isDenormal() && isSignificandAllOnes();

    if (WillCrossBinadeBoundary) {
      integerPart *Parts = significandParts();
      APInt::tcSet(Parts, 0, partCount());
      APInt::tcSetBit(Parts, semantics->precision - 1);
      assert(exponent != semantics->maxExponent &&(static_cast <bool> (exponent != semantics->maxExponent
 && "We can not increment an exponent beyond the maxExponent allowed"
 " by the given floating point semantics.") ? void (0) : __assert_fail
 ("exponent != semantics->maxExponent && \"We can not increment an exponent beyond the maxExponent allowed\" \" by the given floating point semantics.\""
, "llvm/lib/Support/APFloat.cpp", 4398, __extension__ __PRETTY_FUNCTION__
))
             "We can not increment an exponent beyond the maxExponent allowed"(static_cast <bool> (exponent != semantics->maxExponent
 && "We can not increment an exponent beyond the maxExponent allowed"
 " by the given floating point semantics.") ? void (0) : __assert_fail
 ("exponent != semantics->maxExponent && \"We can not increment an exponent beyond the maxExponent allowed\" \" by the given floating point semantics.\""
, "llvm/lib/Support/APFloat.cpp", 4398, __extension__ __PRETTY_FUNCTION__
))
             " by the given floating point semantics.")(static_cast <bool> (exponent != semantics->maxExponent
 && "We can not increment an exponent beyond the maxExponent allowed"
 " by the given floating point semantics.") ? void (0) : __assert_fail
 ("exponent != semantics->maxExponent && \"We can not increment an exponent beyond the maxExponent allowed\" \" by the given floating point semantics.\""
, "llvm/lib/Support/APFloat.cpp", 4398, __extension__ __PRETTY_FUNCTION__
));
      exponent++;
    } else {
      incrementSignificand();
    }
  }
  break;
}

// If we are performing nextDown, swap sign so we have -nextUp(-x)
if (nextDown)
  changeSign();

return result;
4412}

4414APFloatBase::ExponentType IEEEFloat::exponentNaN() const {
return ::exponentNaN(*semantics);
4416}

4418APFloatBase::ExponentType IEEEFloat::exponentInf() const {
return ::exponentInf(*semantics);
4420}

4422APFloatBase::ExponentType IEEEFloat::exponentZero() const {
return ::exponentZero(*semantics);
4424}

4426void IEEEFloat::makeInf(bool Negative) {
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
  // There is no Inf, so make NaN instead.
  makeNaN(false, Negative);
  return;
}
category = fcInfinity;
sign = Negative;
exponent = exponentInf();
APInt::tcSet(significandParts(), 0, partCount());
4436}

4438void IEEEFloat::makeZero(bool Negative) {
category = fcZero;
sign = Negative;
if (semantics->nanEncoding == fltNanEncoding::NegativeZero) {
  // Merge negative zero to positive because 0b10000...000 is used for NaN
  sign = false;
}
exponent = exponentZero();
APInt::tcSet(significandParts(), 0, partCount());
4447}

4449void IEEEFloat::makeQuiet() {
assert(isNaN())(static_cast <bool> (isNaN()) ? void (0) : __assert_fail
 ("isNaN()", "llvm/lib/Support/APFloat.cpp", 4450, __extension__
 __PRETTY_FUNCTION__));
if (semantics->nonFiniteBehavior != fltNonfiniteBehavior::NanOnly)
  APInt::tcSetBit(significandParts(), semantics->precision - 2);
4453}

4455int ilogb(const IEEEFloat &Arg) {
if (Arg.isNaN())
  return IEEEFloat::IEK_NaN;
if (Arg.isZero())
  return IEEEFloat::IEK_Zero;
if (Arg.isInfinity())
  return IEEEFloat::IEK_Inf;
if (!Arg.isDenormal())
  return Arg.exponent;

IEEEFloat Normalized(Arg);
int SignificandBits = Arg.getSemantics().precision - 1;

Normalized.exponent += SignificandBits;
Normalized.normalize(IEEEFloat::rmNearestTiesToEven, lfExactlyZero);
return Normalized.exponent - SignificandBits;
4471}

4473IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode RoundingMode) {
auto MaxExp = X.getSemantics().maxExponent;
auto MinExp = X.getSemantics().minExponent;

// If Exp is wildly out-of-scale, simply adding it to X.exponent will
// overflow; clamp it to a safe range before adding, but ensure that the range
// is large enough that the clamp does not change the result. The range we
// need to support is the difference between the largest possible exponent and
// the normalized exponent of half the smallest denormal.

int SignificandBits = X.getSemantics().precision - 1;
int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;

// Clamp to one past the range ends to let normalize handle overlflow.
X.exponent += std::clamp(Exp, -MaxIncrement - 1, MaxIncrement);
X.normalize(RoundingMode, lfExactlyZero);
if (X.isNaN())
  X.makeQuiet();
return X;
4492}

4494IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM) {
Exp = ilogb(Val);

// Quiet signalling nans.
if (Exp == IEEEFloat::IEK_NaN) {
  IEEEFloat Quiet(Val);
  Quiet.makeQuiet();
  return Quiet;
}

if (Exp == IEEEFloat::IEK_Inf)
  return Val;

// 1 is added because frexp is defined to return a normalized fraction in
// +/-[0.5, 1.0), rather than the usual +/-[1.0, 2.0).
Exp = Exp == IEEEFloat::IEK_Zero ? 0 : Exp + 1;
return scalbn(Val, -Exp, RM);
4511}

4513DoubleAPFloat::DoubleAPFloat(const fltSemantics &S)
  : Semantics(&S),
    Floats(new APFloat[2]{APFloat(semIEEEdouble), APFloat(semIEEEdouble)}) {
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4516, __extension__ __PRETTY_FUNCTION__
));
4517}

4519DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, uninitializedTag)
  : Semantics(&S),
    Floats(new APFloat[2]{APFloat(semIEEEdouble, uninitialized),
                          APFloat(semIEEEdouble, uninitialized)}) {
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4523, __extension__ __PRETTY_FUNCTION__
));
4524}

4526DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, integerPart I)
  : Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
                                         APFloat(semIEEEdouble)}) {
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4529, __extension__ __PRETTY_FUNCTION__
));
4530}

4532DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, const APInt &I)
  : Semantics(&S),
    Floats(new APFloat[2]{
        APFloat(semIEEEdouble, APInt(64, I.getRawData()[0])),
        APFloat(semIEEEdouble, APInt(64, I.getRawData()[1]))}) {
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4537, __extension__ __PRETTY_FUNCTION__
));
4538}

4540DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
                           APFloat &&Second)
  : Semantics(&S),
    Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4544, __extension__ __PRETTY_FUNCTION__
));
assert(&Floats[0].getSemantics() == &semIEEEdouble)(static_cast <bool> (&Floats[0].getSemantics() == &
semIEEEdouble) ? void (0) : __assert_fail ("&Floats[0].getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4545, __extension__ __PRETTY_FUNCTION__
));
assert(&Floats[1].getSemantics() == &semIEEEdouble)(static_cast <bool> (&Floats[1].getSemantics() == &
semIEEEdouble) ? void (0) : __assert_fail ("&Floats[1].getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4546, __extension__ __PRETTY_FUNCTION__
));
4547}

4549DoubleAPFloat::DoubleAPFloat(const DoubleAPFloat &RHS)
  : Semantics(RHS.Semantics),
    Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
12
←
'?' condition is true→
13
←
Memory is allocated→
                                       APFloat(RHS.Floats[1])}
                      : nullptr) {
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4554, __extension__ __PRETTY_FUNCTION__
));
14
←
Assuming the condition is true→
15
←
'?' condition is true→
4555}

4557DoubleAPFloat::DoubleAPFloat(DoubleAPFloat &&RHS)
  : Semantics(RHS.Semantics), Floats(std::move(RHS.Floats)) {
RHS.Semantics = &semBogus;
assert(Semantics == &semPPCDoubleDouble)(static_cast <bool> (Semantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("Semantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 4560, __extension__ __PRETTY_FUNCTION__
));
4561}

4563DoubleAPFloat &DoubleAPFloat::operator=(const DoubleAPFloat &RHS) {
if (Semantics == RHS.Semantics && RHS.Floats) {
  Floats[0] = RHS.Floats[0];
  Floats[1] = RHS.Floats[1];
} else if (this != &RHS) {
  this->~DoubleAPFloat();
  new (this) DoubleAPFloat(RHS);
}
return *this;
4572}

4574// Implement addition, subtraction, multiplication and division based on:
4575// "Software for Doubled-Precision Floating-Point Computations",
4576// by Seppo Linnainmaa, ACM TOMS vol 7 no 3, September 1981, pages 272-283.
4577APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
                                       const APFloat &c, const APFloat &cc,
                                       roundingMode RM) {
int Status = opOK;
APFloat z = a;
Status |= z.add(c, RM);
if (!z.isFinite()) {
  if (!z.isInfinity()) {
    Floats[0] = std::move(z);
    Floats[1].makeZero(/* Neg = */ false);
    return (opStatus)Status;
  }
  Status = opOK;
  auto AComparedToC = a.compareAbsoluteValue(c);
  z = cc;
  Status |= z.add(aa, RM);
  if (AComparedToC == APFloat::cmpGreaterThan) {
    // z = cc + aa + c + a;
    Status |= z.add(c, RM);
    Status |= z.add(a, RM);
  } else {
    // z = cc + aa + a + c;
    Status |= z.add(a, RM);
    Status |= z.add(c, RM);
  }
  if (!z.isFinite()) {
    Floats[0] = std::move(z);
    Floats[1].makeZero(/* Neg = */ false);
    return (opStatus)Status;
  }
  Floats[0] = z;
  APFloat zz = aa;
  Status |= zz.add(cc, RM);
  if (AComparedToC == APFloat::cmpGreaterThan) {
    // Floats[1] = a - z + c + zz;
    Floats[1] = a;
    Status |= Floats[1].subtract(z, RM);
    Status |= Floats[1].add(c, RM);
    Status |= Floats[1].add(zz, RM);
  } else {
    // Floats[1] = c - z + a + zz;
    Floats[1] = c;
    Status |= Floats[1].subtract(z, RM);
    Status |= Floats[1].add(a, RM);
    Status |= Floats[1].add(zz, RM);
  }
} else {
  // q = a - z;
  APFloat q = a;
  Status |= q.subtract(z, RM);

  // zz = q + c + (a - (q + z)) + aa + cc;
  // Compute a - (q + z) as -((q + z) - a) to avoid temporary copies.
  auto zz = q;
  Status |= zz.add(c, RM);
  Status |= q.add(z, RM);
  Status |= q.subtract(a, RM);
  q.changeSign();
  Status |= zz.add(q, RM);
  Status |= zz.add(aa, RM);
  Status |= zz.add(cc, RM);
  if (zz.isZero() && !zz.isNegative()) {
    Floats[0] = std::move(z);
    Floats[1].makeZero(/* Neg = */ false);
    return opOK;
  }
  Floats[0] = z;
  Status |= Floats[0].add(zz, RM);
  if (!Floats[0].isFinite()) {
    Floats[1].makeZero(/* Neg = */ false);
    return (opStatus)Status;
  }
  Floats[1] = std::move(z);
  Status |= Floats[1].subtract(Floats[0], RM);
  Status |= Floats[1].add(zz, RM);
}
return (opStatus)Status;
4654}

4656APFloat::opStatus DoubleAPFloat::addWithSpecial(const DoubleAPFloat &LHS,
                                              const DoubleAPFloat &RHS,
                                              DoubleAPFloat &Out,
                                              roundingMode RM) {
if (LHS.getCategory() == fcNaN) {
  Out = LHS;
  return opOK;
}
if (RHS.getCategory() == fcNaN) {
  Out = RHS;
  return opOK;
}
if (LHS.getCategory() == fcZero) {
  Out = RHS;
  return opOK;
}
if (RHS.getCategory() == fcZero) {
  Out = LHS;
  return opOK;
}
if (LHS.getCategory() == fcInfinity && RHS.getCategory() == fcInfinity &&
    LHS.isNegative() != RHS.isNegative()) {
  Out.makeNaN(false, Out.isNegative(), nullptr);
  return opInvalidOp;
}
if (LHS.getCategory() == fcInfinity) {
  Out = LHS;
  return opOK;
}
if (RHS.getCategory() == fcInfinity) {
  Out = RHS;
  return opOK;
}
assert(LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal)(static_cast <bool> (LHS.getCategory() == fcNormal &&
 RHS.getCategory() == fcNormal) ? void (0) : __assert_fail ("LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal"
, "llvm/lib/Support/APFloat.cpp", 4689, __extension__ __PRETTY_FUNCTION__
));

APFloat A(LHS.Floats[0]), AA(LHS.Floats[1]), C(RHS.Floats[0]),
    CC(RHS.Floats[1]);
assert(&A.getSemantics() == &semIEEEdouble)(static_cast <bool> (&A.getSemantics() == &semIEEEdouble
) ? void (0) : __assert_fail ("&A.getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4693, __extension__ __PRETTY_FUNCTION__
));
assert(&AA.getSemantics() == &semIEEEdouble)(static_cast <bool> (&AA.getSemantics() == &semIEEEdouble
) ? void (0) : __assert_fail ("&AA.getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4694, __extension__ __PRETTY_FUNCTION__
));
assert(&C.getSemantics() == &semIEEEdouble)(static_cast <bool> (&C.getSemantics() == &semIEEEdouble
) ? void (0) : __assert_fail ("&C.getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4695, __extension__ __PRETTY_FUNCTION__
));
assert(&CC.getSemantics() == &semIEEEdouble)(static_cast <bool> (&CC.getSemantics() == &semIEEEdouble
) ? void (0) : __assert_fail ("&CC.getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4696, __extension__ __PRETTY_FUNCTION__
));
assert(&Out.Floats[0].getSemantics() == &semIEEEdouble)(static_cast <bool> (&Out.Floats[0].getSemantics() ==
 &semIEEEdouble) ? void (0) : __assert_fail ("&Out.Floats[0].getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4697, __extension__ __PRETTY_FUNCTION__
));
assert(&Out.Floats[1].getSemantics() == &semIEEEdouble)(static_cast <bool> (&Out.Floats[1].getSemantics() ==
 &semIEEEdouble) ? void (0) : __assert_fail ("&Out.Floats[1].getSemantics() == &semIEEEdouble"
, "llvm/lib/Support/APFloat.cpp", 4698, __extension__ __PRETTY_FUNCTION__
));
return Out.addImpl(A, AA, C, CC, RM);
4700}

4702APFloat::opStatus DoubleAPFloat::add(const DoubleAPFloat &RHS,
                                   roundingMode RM) {
return addWithSpecial(*this, RHS, *this, RM);
4705}

4707APFloat::opStatus DoubleAPFloat::subtract(const DoubleAPFloat &RHS,
                                        roundingMode RM) {
changeSign();
auto Ret = add(RHS, RM);
changeSign();
return Ret;
4713}

4715APFloat::opStatus DoubleAPFloat::multiply(const DoubleAPFloat &RHS,
                                        APFloat::roundingMode RM) {
const auto &LHS = *this;
auto &Out = *this;
/* Interesting observation: For special categories, finding the lowest
   common ancestor of the following layered graph gives the correct
   return category:

      NaN
     /   \
   Zero  Inf
     \   /
     Normal

   e.g. NaN * NaN = NaN
        Zero * Inf = NaN
        Normal * Zero = Zero
        Normal * Inf = Inf
*/
if (LHS.getCategory() == fcNaN) {
  Out = LHS;
  return opOK;
}
if (RHS.getCategory() == fcNaN) {
  Out = RHS;
  return opOK;
}
if ((LHS.getCategory() == fcZero && RHS.getCategory() == fcInfinity) ||
    (LHS.getCategory() == fcInfinity && RHS.getCategory() == fcZero)) {
  Out.makeNaN(false, false, nullptr);
  return opOK;
}
if (LHS.getCategory() == fcZero || LHS.getCategory() == fcInfinity) {
  Out = LHS;
  return opOK;
}
if (RHS.getCategory() == fcZero || RHS.getCategory() == fcInfinity) {
  Out = RHS;
  return opOK;
}
assert(LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal &&(static_cast <bool> (LHS.getCategory() == fcNormal &&
 RHS.getCategory() == fcNormal && "Special cases not handled exhaustively"
) ? void (0) : __assert_fail ("LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal && \"Special cases not handled exhaustively\""
, "llvm/lib/Support/APFloat.cpp", 4756, __extension__ __PRETTY_FUNCTION__
))
       "Special cases not handled exhaustively")(static_cast <bool> (LHS.getCategory() == fcNormal &&
 RHS.getCategory() == fcNormal && "Special cases not handled exhaustively"
) ? void (0) : __assert_fail ("LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal && \"Special cases not handled exhaustively\""
, "llvm/lib/Support/APFloat.cpp", 4756, __extension__ __PRETTY_FUNCTION__
));

int Status = opOK;
APFloat A = Floats[0], B = Floats[1], C = RHS.Floats[0], D = RHS.Floats[1];
// t = a * c
APFloat T = A;
Status |= T.multiply(C, RM);
if (!T.isFiniteNonZero()) {
  Floats[0] = T;
  Floats[1].makeZero(/* Neg = */ false);
  return (opStatus)Status;
}

// tau = fmsub(a, c, t), that is -fmadd(-a, c, t).
APFloat Tau = A;
T.changeSign();
Status |= Tau.fusedMultiplyAdd(C, T, RM);
T.changeSign();
{
  // v = a * d
  APFloat V = A;
  Status |= V.multiply(D, RM);
  // w = b * c
  APFloat W = B;
  Status |= W.multiply(C, RM);
  Status |= V.add(W, RM);
  // tau += v + w
  Status |= Tau.add(V, RM);
}
// u = t + tau
APFloat U = T;
Status |= U.add(Tau, RM);

Floats[0] = U;
if (!U.isFinite()) {
  Floats[1].makeZero(/* Neg = */ false);
} else {
  // Floats[1] = (t - u) + tau
  Status |= T.subtract(U, RM);
  Status |= T.add(Tau, RM);
  Floats[1] = T;
}
return (opStatus)Status;
4799}

4801APFloat::opStatus DoubleAPFloat::divide(const DoubleAPFloat &RHS,
                                      APFloat::roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4803, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
auto Ret =
    Tmp.divide(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()), RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4809}

4811APFloat::opStatus DoubleAPFloat::remainder(const DoubleAPFloat &RHS) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4812, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
auto Ret =
    Tmp.remainder(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()));
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4818}

4820APFloat::opStatus DoubleAPFloat::mod(const DoubleAPFloat &RHS) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4821, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
auto Ret = Tmp.mod(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()));
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4826}

4828APFloat::opStatus
4829DoubleAPFloat::fusedMultiplyAdd(const DoubleAPFloat &Multiplicand,
                              const DoubleAPFloat &Addend,
                              APFloat::roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4832, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
auto Ret = Tmp.fusedMultiplyAdd(
    APFloat(semPPCDoubleDoubleLegacy, Multiplicand.bitcastToAPInt()),
    APFloat(semPPCDoubleDoubleLegacy, Addend.bitcastToAPInt()), RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4839}

4841APFloat::opStatus DoubleAPFloat::roundToIntegral(APFloat::roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4842, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
auto Ret = Tmp.roundToIntegral(RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4847}

4849void DoubleAPFloat::changeSign() {
Floats[0].changeSign();
Floats[1].changeSign();
4852}

4854APFloat::cmpResult
4855DoubleAPFloat::compareAbsoluteValue(const DoubleAPFloat &RHS) const {
auto Result = Floats[0].compareAbsoluteValue(RHS.Floats[0]);
if (Result != cmpEqual)
  return Result;
Result = Floats[1].compareAbsoluteValue(RHS.Floats[1]);
if (Result == cmpLessThan || Result == cmpGreaterThan) {
  auto Against = Floats[0].isNegative() ^ Floats[1].isNegative();
  auto RHSAgainst = RHS.Floats[0].isNegative() ^ RHS.Floats[1].isNegative();
  if (Against && !RHSAgainst)
    return cmpLessThan;
  if (!Against && RHSAgainst)
    return cmpGreaterThan;
  if (!Against && !RHSAgainst)
    return Result;
  if (Against && RHSAgainst)
    return (cmpResult)(cmpLessThan + cmpGreaterThan - Result);
}
return Result;
4873}

4875APFloat::fltCategory DoubleAPFloat::getCategory() const {
return Floats[0].getCategory();
4877}

4879bool DoubleAPFloat::isNegative() const { return Floats[0].isNegative(); }

4881void DoubleAPFloat::makeInf(bool Neg) {
Floats[0].makeInf(Neg);
Floats[1].makeZero(/* Neg = */ false);
4884}

4886void DoubleAPFloat::makeZero(bool Neg) {
Floats[0].makeZero(Neg);
Floats[1].makeZero(/* Neg = */ false);
4889}

4891void DoubleAPFloat::makeLargest(bool Neg) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4892, __extension__ __PRETTY_FUNCTION__
));
Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x7fefffffffffffffull));
Floats[1] = APFloat(semIEEEdouble, APInt(64, 0x7c8ffffffffffffeull));
if (Neg)
  changeSign();
4897}

4899void DoubleAPFloat::makeSmallest(bool Neg) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4900, __extension__ __PRETTY_FUNCTION__
));
Floats[0].makeSmallest(Neg);
Floats[1].makeZero(/* Neg = */ false);
4903}

4905void DoubleAPFloat::makeSmallestNormalized(bool Neg) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4906, __extension__ __PRETTY_FUNCTION__
));
Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x0360000000000000ull));
if (Neg)
  Floats[0].changeSign();
Floats[1].makeZero(/* Neg = */ false);
4911}

4913void DoubleAPFloat::makeNaN(bool SNaN, bool Neg, const APInt *fill) {
Floats[0].makeNaN(SNaN, Neg, fill);
Floats[1].makeZero(/* Neg = */ false);
4916}

4918APFloat::cmpResult DoubleAPFloat::compare(const DoubleAPFloat &RHS) const {
auto Result = Floats[0].compare(RHS.Floats[0]);
// |Float[0]| > |Float[1]|
if (Result == APFloat::cmpEqual)
  return Floats[1].compare(RHS.Floats[1]);
return Result;
4924}

4926bool DoubleAPFloat::bitwiseIsEqual(const DoubleAPFloat &RHS) const {
return Floats[0].bitwiseIsEqual(RHS.Floats[0]) &&
       Floats[1].bitwiseIsEqual(RHS.Floats[1]);
4929}

4931hash_code hash_value(const DoubleAPFloat &Arg) {
if (Arg.Floats)
  return hash_combine(hash_value(Arg.Floats[0]), hash_value(Arg.Floats[1]));
return hash_combine(Arg.Semantics);
4935}

4937APInt DoubleAPFloat::bitcastToAPInt() const {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4938, __extension__ __PRETTY_FUNCTION__
));
uint64_t Data[] = {
    Floats[0].bitcastToAPInt().getRawData()[0],
    Floats[1].bitcastToAPInt().getRawData()[0],
};
return APInt(128, 2, Data);
4944}

4946Expected<APFloat::opStatus> DoubleAPFloat::convertFromString(StringRef S,
                                                           roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4948, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy);
auto Ret = Tmp.convertFromString(S, RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4953}

4955APFloat::opStatus DoubleAPFloat::next(bool nextDown) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4956, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
auto Ret = Tmp.next(nextDown);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4961}

4963APFloat::opStatus
4964DoubleAPFloat::convertToInteger(MutableArrayRef<integerPart> Input,
                              unsigned int Width, bool IsSigned,
                              roundingMode RM, bool *IsExact) const {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4967, __extension__ __PRETTY_FUNCTION__
));
return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
    .convertToInteger(Input, Width, IsSigned, RM, IsExact);
4970}

4972APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
                                                bool IsSigned,
                                                roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4975, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy);
auto Ret = Tmp.convertFromAPInt(Input, IsSigned, RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4980}

4982APFloat::opStatus
4983DoubleAPFloat::convertFromSignExtendedInteger(const integerPart *Input,
                                            unsigned int InputSize,
                                            bool IsSigned, roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4986, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy);
auto Ret = Tmp.convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
4991}

4993APFloat::opStatus
4994DoubleAPFloat::convertFromZeroExtendedInteger(const integerPart *Input,
                                            unsigned int InputSize,
                                            bool IsSigned, roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 4997, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy);
auto Ret = Tmp.convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM);
*this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
return Ret;
5002}

5004unsigned int DoubleAPFloat::convertToHexString(char *DST,
                                             unsigned int HexDigits,
                                             bool UpperCase,
                                             roundingMode RM) const {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 5008, __extension__ __PRETTY_FUNCTION__
));
return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
    .convertToHexString(DST, HexDigits, UpperCase, RM);
5011}

5013bool DoubleAPFloat::isDenormal() const {
return getCategory() == fcNormal &&
       (Floats[0].isDenormal() || Floats[1].isDenormal() ||
        // (double)(Hi + Lo) == Hi defines a normal number.
        Floats[0] != Floats[0] + Floats[1]);
5018}

5020bool DoubleAPFloat::isSmallest() const {
if (getCategory() != fcNormal)
  return false;
DoubleAPFloat Tmp(*this);
Tmp.makeSmallest(this->isNegative());
return Tmp.compare(*this) == cmpEqual;
5026}

5028bool DoubleAPFloat::isSmallestNormalized() const {
if (getCategory() != fcNormal)
  return false;

DoubleAPFloat Tmp(*this);
Tmp.makeSmallestNormalized(this->isNegative());
return Tmp.compare(*this) == cmpEqual;
5035}

5037bool DoubleAPFloat::isLargest() const {
if (getCategory() != fcNormal)
  return false;
DoubleAPFloat Tmp(*this);
Tmp.makeLargest(this->isNegative());
return Tmp.compare(*this) == cmpEqual;
5043}

5045bool DoubleAPFloat::isInteger() const {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 5046, __extension__ __PRETTY_FUNCTION__
));
return Floats[0].isInteger() && Floats[1].isInteger();
5048}

5050void DoubleAPFloat::toString(SmallVectorImpl<char> &Str,
                           unsigned FormatPrecision,
                           unsigned FormatMaxPadding,
                           bool TruncateZero) const {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 5054, __extension__ __PRETTY_FUNCTION__
));
APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
    .toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero);
5057}

5059bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 5060, __extension__ __PRETTY_FUNCTION__
));
APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
if (!inv)
  return Tmp.getExactInverse(nullptr);
APFloat Inv(semPPCDoubleDoubleLegacy);
auto Ret = Tmp.getExactInverse(&Inv);
*inv = APFloat(semPPCDoubleDouble, Inv.bitcastToAPInt());
return Ret;
5068}

5070DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp,
                   APFloat::roundingMode RM) {
assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Arg.Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Arg.Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 5072, __extension__ __PRETTY_FUNCTION__
));
return DoubleAPFloat(semPPCDoubleDouble, scalbn(Arg.Floats[0], Exp, RM),
                     scalbn(Arg.Floats[1], Exp, RM));
5075}

5077DoubleAPFloat frexp(const DoubleAPFloat &Arg, int &Exp,
                  APFloat::roundingMode RM) {
assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics")(static_cast <bool> (Arg.Semantics == &semPPCDoubleDouble
 && "Unexpected Semantics") ? void (0) : __assert_fail
 ("Arg.Semantics == &semPPCDoubleDouble && \"Unexpected Semantics\""
, "llvm/lib/Support/APFloat.cpp", 5079, __extension__ __PRETTY_FUNCTION__
));
1
Assuming the condition is true→
2
←
'?' condition is true→
APFloat First = frexp(Arg.Floats[0], Exp, RM);
APFloat Second = Arg.Floats[1];
if (Arg.getCategory() == APFloat::fcNormal)
3
←
Assuming the condition is true→
4
←
Taking true branch→
  Second = scalbn(Second, -Exp, RM);
5
←
Calling defaulted copy constructor for 'APFloat'→
18
←
Returning from copy constructor for 'APFloat'→
return DoubleAPFloat(semPPCDoubleDouble, std::move(First), std::move(Second));
19
←
Potential memory leak
5085}

5087} // namespace detail

5089APFloat::Storage::Storage(IEEEFloat F, const fltSemantics &Semantics) {
if (usesLayout<IEEEFloat>(Semantics)) {
  new (&IEEE) IEEEFloat(std::move(F));
  return;
}
if (usesLayout<DoubleAPFloat>(Semantics)) {
  const fltSemantics& S = F.getSemantics();
  new (&Double)
      DoubleAPFloat(Semantics, APFloat(std::move(F), S),
                    APFloat(semIEEEdouble));
  return;
}
llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/lib/Support/APFloat.cpp"
, 5101);
5102}

5104Expected<APFloat::opStatus> APFloat::convertFromString(StringRef Str,
                                                     roundingMode RM) {
APFLOAT_DISPATCH_ON_SEMANTICS(convertFromString(Str, RM));
5107}

5109hash_code hash_value(const APFloat &Arg) {
if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics()))
  return hash_value(Arg.U.IEEE);
if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics()))
  return hash_value(Arg.U.Double);
llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/lib/Support/APFloat.cpp"
, 5114);
5115}

5117APFloat::APFloat(const fltSemantics &Semantics, StringRef S)
  : APFloat(Semantics) {
auto StatusOrErr = convertFromString(S, rmNearestTiesToEven);
assert(StatusOrErr && "Invalid floating point representation")(static_cast <bool> (StatusOrErr && "Invalid floating point representation"
) ? void (0) : __assert_fail ("StatusOrErr && \"Invalid floating point representation\""
, "llvm/lib/Support/APFloat.cpp", 5120, __extension__ __PRETTY_FUNCTION__
));
consumeError(StatusOrErr.takeError());
5122}

5124FPClassTest APFloat::classify() const {
if (isZero())
  return isNegative() ? fcNegZero : fcPosZero;
if (isNormal())
  return isNegative() ? fcNegNormal : fcPosNormal;
if (isDenormal())
  return isNegative() ? fcNegSubnormal : fcPosSubnormal;
if (isInfinity())
  return isNegative() ? fcNegInf : fcPosInf;
assert(isNaN() && "Other class of FP constant")(static_cast <bool> (isNaN() && "Other class of FP constant"
) ? void (0) : __assert_fail ("isNaN() && \"Other class of FP constant\""
, "llvm/lib/Support/APFloat.cpp", 5133, __extension__ __PRETTY_FUNCTION__
));
return isSignaling() ? fcSNan : fcQNan;
5135}

5137APFloat::opStatus APFloat::convert(const fltSemantics &ToSemantics,
                                 roundingMode RM, bool *losesInfo) {
if (&getSemantics() == &ToSemantics) {
  *losesInfo = false;
  return opOK;
}
if (usesLayout<IEEEFloat>(getSemantics()) &&
    usesLayout<IEEEFloat>(ToSemantics))
  return U.IEEE.convert(ToSemantics, RM, losesInfo);
if (usesLayout<IEEEFloat>(getSemantics()) &&
    usesLayout<DoubleAPFloat>(ToSemantics)) {
  assert(&ToSemantics == &semPPCDoubleDouble)(static_cast <bool> (&ToSemantics == &semPPCDoubleDouble
) ? void (0) : __assert_fail ("&ToSemantics == &semPPCDoubleDouble"
, "llvm/lib/Support/APFloat.cpp", 5148, __extension__ __PRETTY_FUNCTION__
));
  auto Ret = U.IEEE.convert(semPPCDoubleDoubleLegacy, RM, losesInfo);
  *this = APFloat(ToSemantics, U.IEEE.bitcastToAPInt());
  return Ret;
}
if (usesLayout<DoubleAPFloat>(getSemantics()) &&
    usesLayout<IEEEFloat>(ToSemantics)) {
  auto Ret = getIEEE().convert(ToSemantics, RM, losesInfo);
  *this = APFloat(std::move(getIEEE()), ToSemantics);
  return Ret;
}
llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/lib/Support/APFloat.cpp"
, 5159);
5160}

5162APFloat APFloat::getAllOnesValue(const fltSemantics &Semantics) {
return APFloat(Semantics, APInt::getAllOnes(Semantics.sizeInBits));
5164}

5166void APFloat::print(raw_ostream &OS) const {
SmallVector<char, 16> Buffer;
toString(Buffer);
OS << Buffer << "\n";
5170}

5172#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
5173LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void APFloat::dump() const { print(dbgs()); }
5174#endif

5176void APFloat::Profile(FoldingSetNodeID &NID) const {
NID.Add(bitcastToAPInt());
5178}

5180/* Same as convertToInteger(integerPart*, ...), except the result is returned in
 an APSInt, whose initial bit-width and signed-ness are used to determine the
 precision of the conversion.
*/
5184APFloat::opStatus APFloat::convertToInteger(APSInt &result,
                                          roundingMode rounding_mode,
                                          bool *isExact) const {
unsigned bitWidth = result.getBitWidth();
SmallVector<uint64_t, 4> parts(result.getNumWords());
opStatus status = convertToInteger(parts, bitWidth, result.isSigned(),
                                   rounding_mode, isExact);
// Keeps the original signed-ness.
result = APInt(bitWidth, parts);
return status;
5194}

5196double APFloat::convertToDouble() const {
if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEdouble)
  return getIEEE().convertToDouble();
assert(getSemantics().isRepresentableBy(semIEEEdouble) &&(static_cast <bool> (getSemantics().isRepresentableBy(semIEEEdouble
) && "Float semantics is not representable by IEEEdouble"
) ? void (0) : __assert_fail ("getSemantics().isRepresentableBy(semIEEEdouble) && \"Float semantics is not representable by IEEEdouble\""
, "llvm/lib/Support/APFloat.cpp", 5200, __extension__ __PRETTY_FUNCTION__
))
       "Float semantics is not representable by IEEEdouble")(static_cast <bool> (getSemantics().isRepresentableBy(semIEEEdouble
) && "Float semantics is not representable by IEEEdouble"
) ? void (0) : __assert_fail ("getSemantics().isRepresentableBy(semIEEEdouble) && \"Float semantics is not representable by IEEEdouble\""
, "llvm/lib/Support/APFloat.cpp", 5200, __extension__ __PRETTY_FUNCTION__
));
APFloat Temp = *this;
bool LosesInfo;
opStatus St = Temp.convert(semIEEEdouble, rmNearestTiesToEven, &LosesInfo);
assert(!(St & opInexact) && !LosesInfo && "Unexpected imprecision")(static_cast <bool> (!(St & opInexact) && !
LosesInfo && "Unexpected imprecision") ? void (0) : __assert_fail
 ("!(St & opInexact) && !LosesInfo && \"Unexpected imprecision\""
, "llvm/lib/Support/APFloat.cpp", 5204, __extension__ __PRETTY_FUNCTION__
));
(void)St;
return Temp.getIEEE().convertToDouble();
5207}

5209float APFloat::convertToFloat() const {
if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEsingle)
  return getIEEE().convertToFloat();
assert(getSemantics().isRepresentableBy(semIEEEsingle) &&(static_cast <bool> (getSemantics().isRepresentableBy(semIEEEsingle
) && "Float semantics is not representable by IEEEsingle"
) ? void (0) : __assert_fail ("getSemantics().isRepresentableBy(semIEEEsingle) && \"Float semantics is not representable by IEEEsingle\""
, "llvm/lib/Support/APFloat.cpp", 5213, __extension__ __PRETTY_FUNCTION__
))
       "Float semantics is not representable by IEEEsingle")(static_cast <bool> (getSemantics().isRepresentableBy(semIEEEsingle
) && "Float semantics is not representable by IEEEsingle"
) ? void (0) : __assert_fail ("getSemantics().isRepresentableBy(semIEEEsingle) && \"Float semantics is not representable by IEEEsingle\""
, "llvm/lib/Support/APFloat.cpp", 5213, __extension__ __PRETTY_FUNCTION__
));
APFloat Temp = *this;
bool LosesInfo;
opStatus St = Temp.convert(semIEEEsingle, rmNearestTiesToEven, &LosesInfo);
assert(!(St & opInexact) && !LosesInfo && "Unexpected imprecision")(static_cast <bool> (!(St & opInexact) && !
LosesInfo && "Unexpected imprecision") ? void (0) : __assert_fail
 ("!(St & opInexact) && !LosesInfo && \"Unexpected imprecision\""
, "llvm/lib/Support/APFloat.cpp", 5217, __extension__ __PRETTY_FUNCTION__
));
(void)St;
return Temp.getIEEE().convertToFloat();
5220}

5222} // namespace llvm

5224#undef APFLOAT_DISPATCH_ON_SEMANTICS

←

/build/source/llvm/include/llvm/ADT/APFloat.h

1//===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file declares a class to represent arbitrary precision floating point
11/// values and provide a variety of arithmetic operations on them.
12///
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_ADT_APFLOAT_H
16#define LLVM_ADT_APFLOAT_H

18#include "llvm/ADT/APInt.h"
19#include "llvm/ADT/ArrayRef.h"
20#include "llvm/ADT/FloatingPointMode.h"
21#include "llvm/Support/ErrorHandling.h"
22#include <memory>

24#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)                             \
do {                                                                         \
  if (usesLayout<IEEEFloat>(getSemantics()))                                 \
    return U.IEEE.METHOD_CALL;                                               \
  if (usesLayout<DoubleAPFloat>(getSemantics()))                             \
    return U.Double.METHOD_CALL;                                             \
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 30);                                  \
} while (false)

33namespace llvm {

35struct fltSemantics;
36class APSInt;
37class StringRef;
38class APFloat;
39class raw_ostream;

41template <typename T> class Expected;
42template <typename T> class SmallVectorImpl;

44/// Enum that represents what fraction of the LSB truncated bits of an fp number
45/// represent.
46///
47/// This essentially combines the roles of guard and sticky bits.
48enum lostFraction { // Example of truncated bits:
lfExactlyZero,    // 000000
lfLessThanHalf,   // 0xxxxx  x's not all zero
lfExactlyHalf,    // 100000
lfMoreThanHalf    // 1xxxxx  x's not all zero
53};

55/// A self-contained host- and target-independent arbitrary-precision
56/// floating-point software implementation.
57///
58/// APFloat uses bignum integer arithmetic as provided by static functions in
59/// the APInt class.  The library will work with bignum integers whose parts are
60/// any unsigned type at least 16 bits wide, but 64 bits is recommended.
61///
62/// Written for clarity rather than speed, in particular with a view to use in
63/// the front-end of a cross compiler so that target arithmetic can be correctly
64/// performed on the host.  Performance should nonetheless be reasonable,
65/// particularly for its intended use.  It may be useful as a base
66/// implementation for a run-time library during development of a faster
67/// target-specific one.
68///
69/// All 5 rounding modes in the IEEE-754R draft are handled correctly for all
70/// implemented operations.  Currently implemented operations are add, subtract,
71/// multiply, divide, fused-multiply-add, conversion-to-float,
72/// conversion-to-integer and conversion-from-integer.  New rounding modes
73/// (e.g. away from zero) can be added with three or four lines of code.
74///
75/// Four formats are built-in: IEEE single precision, double precision,
76/// quadruple precision, and x87 80-bit extended double (when operating with
77/// full extended precision).  Adding a new format that obeys IEEE semantics
78/// only requires adding two lines of code: a declaration and definition of the
79/// format.
80///
81/// All operations return the status of that operation as an exception bit-mask,
82/// so multiple operations can be done consecutively with their results or-ed
83/// together.  The returned status can be useful for compiler diagnostics; e.g.,
84/// inexact, underflow and overflow can be easily diagnosed on constant folding,
85/// and compiler optimizers can determine what exceptions would be raised by
86/// folding operations and optimize, or perhaps not optimize, accordingly.
87///
88/// At present, underflow tininess is detected after rounding; it should be
89/// straight forward to add support for the before-rounding case too.
90///
91/// The library reads hexadecimal floating point numbers as per C99, and
92/// correctly rounds if necessary according to the specified rounding mode.
93/// Syntax is required to have been validated by the caller.  It also converts
94/// floating point numbers to hexadecimal text as per the C99 %a and %A
95/// conversions.  The output precision (or alternatively the natural minimal
96/// precision) can be specified; if the requested precision is less than the
97/// natural precision the output is correctly rounded for the specified rounding
98/// mode.
99///
100/// It also reads decimal floating point numbers and correctly rounds according
101/// to the specified rounding mode.
102///
103/// Conversion to decimal text is not currently implemented.
104///
105/// Non-zero finite numbers are represented internally as a sign bit, a 16-bit
106/// signed exponent, and the significand as an array of integer parts.  After
107/// normalization of a number of precision P the exponent is within the range of
108/// the format, and if the number is not denormal the P-th bit of the
109/// significand is set as an explicit integer bit.  For denormals the most
110/// significant bit is shifted right so that the exponent is maintained at the
111/// format's minimum, so that the smallest denormal has just the least
112/// significant bit of the significand set.  The sign of zeroes and infinities
113/// is significant; the exponent and significand of such numbers is not stored,
114/// but has a known implicit (deterministic) value: 0 for the significands, 0
115/// for zero exponent, all 1 bits for infinity exponent.  For NaNs the sign and
116/// significand are deterministic, although not really meaningful, and preserved
117/// in non-conversion operations.  The exponent is implicitly all 1 bits.
118///
119/// APFloat does not provide any exception handling beyond default exception
120/// handling. We represent Signaling NaNs via IEEE-754R 2008 6.2.1 should clause
121/// by encoding Signaling NaNs with the first bit of its trailing significand as
122/// 0.
123///
124/// TODO
125/// ====
126///
127/// Some features that may or may not be worth adding:
128///
129/// Binary to decimal conversion (hard).
130///
131/// Optional ability to detect underflow tininess before rounding.
132///
133/// New formats: x87 in single and double precision mode (IEEE apart from
134/// extended exponent range) (hard).
135///
136/// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward.
137///

139// This is the common type definitions shared by APFloat and its internal
140// implementation classes. This struct should not define any non-static data
141// members.
142struct APFloatBase {
typedef APInt::WordType integerPart;
static constexpr unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;

/// A signed type to represent a floating point numbers unbiased exponent.
typedef int32_t ExponentType;

/// \name Floating Point Semantics.
/// @{
enum Semantics {
  S_IEEEhalf,
  S_BFloat,
  S_IEEEsingle,
  S_IEEEdouble,
  S_IEEEquad,
  S_PPCDoubleDouble,
  // 8-bit floating point number following IEEE-754 conventions with bit
  // layout S1E5M2 as described in https://arxiv.org/abs/2209.05433.
  S_Float8E5M2,
  // 8-bit floating point number mostly following IEEE-754 conventions
  // and bit layout S1E5M2 described in https://arxiv.org/abs/2206.02915,
  // with expanded range and with no infinity or signed zero.
  // NaN is represented as negative zero. (FN -> Finite, UZ -> unsigned zero).
  // This format's exponent bias is 16, instead of the 15 (2 ** (5 - 1) - 1)
  // that IEEE precedent would imply.
  S_Float8E5M2FNUZ,
  // 8-bit floating point number mostly following IEEE-754 conventions with
  // bit layout S1E4M3 as described in https://arxiv.org/abs/2209.05433.
  // Unlike IEEE-754 types, there are no infinity values, and NaN is
  // represented with the exponent and mantissa bits set to all 1s.
  S_Float8E4M3FN,
  // 8-bit floating point number mostly following IEEE-754 conventions
  // and bit layout S1E4M3 described in https://arxiv.org/abs/2206.02915,
  // with expanded range and with no infinity or signed zero.
  // NaN is represented as negative zero. (FN -> Finite, UZ -> unsigned zero).
  // This format's exponent bias is 8, instead of the 7 (2 ** (4 - 1) - 1)
  // that IEEE precedent would imply.
  S_Float8E4M3FNUZ,
  // 8-bit floating point number mostly following IEEE-754 conventions
  // and bit layout S1E4M3 with expanded range and with no infinity or signed
  // zero.
  // NaN is represented as negative zero. (FN -> Finite, UZ -> unsigned zero).
  // This format's exponent bias is 11, instead of the 7 (2 ** (4 - 1) - 1)
  // that IEEE precedent would imply.
  S_Float8E4M3B11FNUZ,

  S_x87DoubleExtended,
  S_MaxSemantics = S_x87DoubleExtended,
};

static const llvm::fltSemantics &EnumToSemantics(Semantics S);
static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem);

static const fltSemantics &IEEEhalf() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &BFloat() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &IEEEsingle() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &IEEEdouble() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &IEEEquad() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &PPCDoubleDouble() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &Float8E5M2() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &Float8E5M2FNUZ() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &Float8E4M3FN() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &Float8E4M3FNUZ() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &Float8E4M3B11FNUZ() LLVM_READNONE__attribute__((__const__));
static const fltSemantics &x87DoubleExtended() LLVM_READNONE__attribute__((__const__));

/// A Pseudo fltsemantic used to construct APFloats that cannot conflict with
/// anything real.
static const fltSemantics &Bogus() LLVM_READNONE__attribute__((__const__));

/// @}

/// IEEE-754R 5.11: Floating Point Comparison Relations.
enum cmpResult {
  cmpLessThan,
  cmpEqual,
  cmpGreaterThan,
  cmpUnordered
};

/// IEEE-754R 4.3: Rounding-direction attributes.
using roundingMode = llvm::RoundingMode;

static constexpr roundingMode rmNearestTiesToEven =
                                              RoundingMode::NearestTiesToEven;
static constexpr roundingMode rmTowardPositive = RoundingMode::TowardPositive;
static constexpr roundingMode rmTowardNegative = RoundingMode::TowardNegative;
static constexpr roundingMode rmTowardZero     = RoundingMode::TowardZero;
static constexpr roundingMode rmNearestTiesToAway =
                                              RoundingMode::NearestTiesToAway;

/// IEEE-754R 7: Default exception handling.
///
/// opUnderflow or opOverflow are always returned or-ed with opInexact.
///
/// APFloat models this behavior specified by IEEE-754:
///   "For operations producing results in floating-point format, the default
///    result of an operation that signals the invalid operation exception
///    shall be a quiet NaN."
enum opStatus {
  opOK = 0x00,
  opInvalidOp = 0x01,
  opDivByZero = 0x02,
  opOverflow = 0x04,
  opUnderflow = 0x08,
  opInexact = 0x10
};

/// Category of internally-represented number.
enum fltCategory {
  fcInfinity,
  fcNaN,
  fcNormal,
  fcZero
};

/// Convenience enum used to construct an uninitialized APFloat.
enum uninitializedTag {
  uninitialized
};

/// Enumeration of \c ilogb error results.
enum IlogbErrorKinds {
  IEK_Zero = INT_MIN(-2147483647 -1) + 1,
  IEK_NaN = INT_MIN(-2147483647 -1),
  IEK_Inf = INT_MAX2147483647
};

static unsigned int semanticsPrecision(const fltSemantics &);
static ExponentType semanticsMinExponent(const fltSemantics &);
static ExponentType semanticsMaxExponent(const fltSemantics &);
static unsigned int semanticsSizeInBits(const fltSemantics &);
static unsigned int semanticsIntSizeInBits(const fltSemantics&, bool);

// Returns true if any number described by \p Src can be precisely represented
// by a normal (not subnormal) value in \p Dst.
static bool isRepresentableAsNormalIn(const fltSemantics &Src,
                                      const fltSemantics &Dst);

/// Returns the size of the floating point number (in bits) in the given
/// semantics.
static unsigned getSizeInBits(const fltSemantics &Sem);
284};

286namespace detail {

288class IEEEFloat final : public APFloatBase {
289public:
/// \name Constructors
/// @{

IEEEFloat(const fltSemantics &); // Default construct to +0.0
IEEEFloat(const fltSemantics &, integerPart);
IEEEFloat(const fltSemantics &, uninitializedTag);
IEEEFloat(const fltSemantics &, const APInt &);
explicit IEEEFloat(double d);
explicit IEEEFloat(float f);
IEEEFloat(const IEEEFloat &);
IEEEFloat(IEEEFloat &&);
~IEEEFloat();

/// @}

/// Returns whether this instance allocated memory.
bool needsCleanup() const { return partCount() > 1; }

/// \name Convenience "constructors"
/// @{

/// @}

/// \name Arithmetic
/// @{

opStatus add(const IEEEFloat &, roundingMode);
opStatus subtract(const IEEEFloat &, roundingMode);
opStatus multiply(const IEEEFloat &, roundingMode);
opStatus divide(const IEEEFloat &, roundingMode);
/// IEEE remainder.
opStatus remainder(const IEEEFloat &);
/// C fmod, or llvm frem.
opStatus mod(const IEEEFloat &);
opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode);
opStatus roundToIntegral(roundingMode);
/// IEEE-754R 5.3.1: nextUp/nextDown.
opStatus next(bool nextDown);

/// @}

/// \name Sign operations.
/// @{

void changeSign();

/// @}

/// \name Conversions
/// @{

opStatus convert(const fltSemantics &, roundingMode, bool *);
opStatus convertToInteger(MutableArrayRef<integerPart>, unsigned int, bool,
                          roundingMode, bool *) const;
opStatus convertFromAPInt(const APInt &, bool, roundingMode);
opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int,
                                        bool, roundingMode);
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
                                        bool, roundingMode);
Expected<opStatus> convertFromString(StringRef, roundingMode);
APInt bitcastToAPInt() const;
double convertToDouble() const;
float convertToFloat() const;

/// @}

/// The definition of equality is not straightforward for floating point, so
/// we won't use operator==.  Use one of the following, or write whatever it
/// is you really mean.
bool operator==(const IEEEFloat &) const = delete;

/// IEEE comparison with another floating point number (NaNs compare
/// unordered, 0==-0).
cmpResult compare(const IEEEFloat &) const;

/// Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
bool bitwiseIsEqual(const IEEEFloat &) const;

/// Write out a hexadecimal representation of the floating point value to DST,
/// which must be of sufficient size, in the C99 form [-]0xh.hhhhp[+-]d.
/// Return the number of characters written, excluding the terminating NUL.
unsigned int convertToHexString(char *dst, unsigned int hexDigits,
                                bool upperCase, roundingMode) const;

/// \name IEEE-754R 5.7.2 General operations.
/// @{

/// IEEE-754R isSignMinus: Returns true if and only if the current value is
/// negative.
///
/// This applies to zeros and NaNs as well.
bool isNegative() const { return sign; }

/// IEEE-754R isNormal: Returns true if and only if the current value is normal.
///
/// This implies that the current value of the float is not zero, subnormal,
/// infinite, or NaN following the definition of normality from IEEE-754R.
bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }

/// Returns true if and only if the current value is zero, subnormal, or
/// normal.
///
/// This means that the value is not infinite or NaN.
bool isFinite() const { return !isNaN() && !isInfinity(); }

/// Returns true if and only if the float is plus or minus zero.
bool isZero() const { return category == fcZero; }

/// IEEE-754R isSubnormal(): Returns true if and only if the float is a
/// denormal.
bool isDenormal() const;

/// IEEE-754R isInfinite(): Returns true if and only if the float is infinity.
bool isInfinity() const { return category == fcInfinity; }

/// Returns true if and only if the float is a quiet or signaling NaN.
bool isNaN() const { return category == fcNaN; }

/// Returns true if and only if the float is a signaling NaN.
bool isSignaling() const;

/// @}

/// \name Simple Queries
/// @{

fltCategory getCategory() const { return category; }
const fltSemantics &getSemantics() const { return *semantics; }
bool isNonZero() const { return category != fcZero; }
bool isFiniteNonZero() const { return isFinite() && !isZero(); }
bool isPosZero() const { return isZero() && !isNegative(); }
bool isNegZero() const { return isZero() && isNegative(); }

/// Returns true if and only if the number has the smallest possible non-zero
/// magnitude in the current semantics.
bool isSmallest() const;

/// Returns true if this is the smallest (by magnitude) normalized finite
/// number in the given semantics.
bool isSmallestNormalized() const;

/// Returns true if and only if the number has the largest possible finite
/// magnitude in the current semantics.
bool isLargest() const;

/// Returns true if and only if the number is an exact integer.
bool isInteger() const;

/// @}

IEEEFloat &operator=(const IEEEFloat &);
IEEEFloat &operator=(IEEEFloat &&);

/// Overload to compute a hash code for an APFloat value.
///
/// Note that the use of hash codes for floating point values is in general
/// frought with peril. Equality is hard to define for these values. For
/// example, should negative and positive zero hash to different codes? Are
/// they equal or not? This hash value implementation specifically
/// emphasizes producing different codes for different inputs in order to
/// be used in canonicalization and memoization. As such, equality is
/// bitwiseIsEqual, and 0 != -0.
friend hash_code hash_value(const IEEEFloat &Arg);

/// Converts this value into a decimal string.
///
/// \param FormatPrecision The maximum number of digits of
///   precision to output.  If there are fewer digits available,
///   zero padding will not be used unless the value is
///   integral and small enough to be expressed in
///   FormatPrecision digits.  0 means to use the natural
///   precision of the number.
/// \param FormatMaxPadding The maximum number of zeros to
///   consider inserting before falling back to scientific
///   notation.  0 means to always use scientific notation.
///
/// \param TruncateZero Indicate whether to remove the trailing zero in
///   fraction part or not. Also setting this parameter to false forcing
///   producing of output more similar to default printf behavior.
///   Specifically the lower e is used as exponent delimiter and exponent
///   always contains no less than two digits.
///
/// Number       Precision    MaxPadding      Result
/// ------       ---------    ----------      ------
/// 1.01E+4              5             2       10100
/// 1.01E+4              4             2       1.01E+4
/// 1.01E+4              5             1       1.01E+4
/// 1.01E-2              5             2       0.0101
/// 1.01E-2              4             2       0.0101
/// 1.01E-2              4             1       1.01E-2
void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
              unsigned FormatMaxPadding = 3, bool TruncateZero = true) const;

/// If this value has an exact multiplicative inverse, store it in inv and
/// return true.
bool getExactInverse(APFloat *inv) const;

/// Returns the exponent of the internal representation of the APFloat.
///
/// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
/// For special APFloat values, this returns special error codes:
///
///   NaN -> \c IEK_NaN
///   0   -> \c IEK_Zero
///   Inf -> \c IEK_Inf
///
friend int ilogb(const IEEEFloat &Arg);

/// Returns: X * 2^Exp for integral exponents.
friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode);

friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode);

/// \name Special value setters.
/// @{

void makeLargest(bool Neg = false);
void makeSmallest(bool Neg = false);
void makeNaN(bool SNaN = false, bool Neg = false,
             const APInt *fill = nullptr);
void makeInf(bool Neg = false);
void makeZero(bool Neg = false);
void makeQuiet();

/// Returns the smallest (by magnitude) normalized finite number in the given
/// semantics.
///
/// \param Negative - True iff the number should be negative
void makeSmallestNormalized(bool Negative = false);

/// @}

cmpResult compareAbsoluteValue(const IEEEFloat &) const;

524private:
/// \name Simple Queries
/// @{

integerPart *significandParts();
const integerPart *significandParts() const;
unsigned int partCount() const;

/// @}

/// \name Significand operations.
/// @{

integerPart addSignificand(const IEEEFloat &);
integerPart subtractSignificand(const IEEEFloat &, integerPart);
lostFraction addOrSubtractSignificand(const IEEEFloat &, bool subtract);
lostFraction multiplySignificand(const IEEEFloat &, IEEEFloat);
lostFraction multiplySignificand(const IEEEFloat&);
lostFraction divideSignificand(const IEEEFloat &);
void incrementSignificand();
void initialize(const fltSemantics *);
void shiftSignificandLeft(unsigned int);
lostFraction shiftSignificandRight(unsigned int);
unsigned int significandLSB() const;
unsigned int significandMSB() const;
void zeroSignificand();
/// Return true if the significand excluding the integral bit is all ones.
bool isSignificandAllOnes() const;
bool isSignificandAllOnesExceptLSB() const;
/// Return true if the significand excluding the integral bit is all zeros.
bool isSignificandAllZeros() const;
bool isSignificandAllZerosExceptMSB() const;

/// @}

/// \name Arithmetic on special values.
/// @{

opStatus addOrSubtractSpecials(const IEEEFloat &, bool subtract);
opStatus divideSpecials(const IEEEFloat &);
opStatus multiplySpecials(const IEEEFloat &);
opStatus modSpecials(const IEEEFloat &);
opStatus remainderSpecials(const IEEEFloat&);

/// @}

/// \name Miscellany
/// @{

bool convertFromStringSpecials(StringRef str);
opStatus normalize(roundingMode, lostFraction);
opStatus addOrSubtract(const IEEEFloat &, roundingMode, bool subtract);
opStatus handleOverflow(roundingMode);
bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const;
opStatus convertToSignExtendedInteger(MutableArrayRef<integerPart>,
                                      unsigned int, bool, roundingMode,
                                      bool *) const;
opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
                                  roundingMode);
Expected<opStatus> convertFromHexadecimalString(StringRef, roundingMode);
Expected<opStatus> convertFromDecimalString(StringRef, roundingMode);
char *convertNormalToHexString(char *, unsigned int, bool,
                               roundingMode) const;
opStatus roundSignificandWithExponent(const integerPart *, unsigned int, int,
                                      roundingMode);
ExponentType exponentNaN() const;
ExponentType exponentInf() const;
ExponentType exponentZero() const;

/// @}

template <const fltSemantics &S> APInt convertIEEEFloatToAPInt() const;
APInt convertHalfAPFloatToAPInt() const;
APInt convertBFloatAPFloatToAPInt() const;
APInt convertFloatAPFloatToAPInt() const;
APInt convertDoubleAPFloatToAPInt() const;
APInt convertQuadrupleAPFloatToAPInt() const;
APInt convertF80LongDoubleAPFloatToAPInt() const;
APInt convertPPCDoubleDoubleAPFloatToAPInt() const;
APInt convertFloat8E5M2APFloatToAPInt() const;
APInt convertFloat8E5M2FNUZAPFloatToAPInt() const;
APInt convertFloat8E4M3FNAPFloatToAPInt() const;
APInt convertFloat8E4M3FNUZAPFloatToAPInt() const;
APInt convertFloat8E4M3B11FNUZAPFloatToAPInt() const;
void initFromAPInt(const fltSemantics *Sem, const APInt &api);
template <const fltSemantics &S> void initFromIEEEAPInt(const APInt &api);
void initFromHalfAPInt(const APInt &api);
void initFromBFloatAPInt(const APInt &api);
void initFromFloatAPInt(const APInt &api);
void initFromDoubleAPInt(const APInt &api);
void initFromQuadrupleAPInt(const APInt &api);
void initFromF80LongDoubleAPInt(const APInt &api);
void initFromPPCDoubleDoubleAPInt(const APInt &api);
void initFromFloat8E5M2APInt(const APInt &api);
void initFromFloat8E5M2FNUZAPInt(const APInt &api);
void initFromFloat8E4M3FNAPInt(const APInt &api);
void initFromFloat8E4M3FNUZAPInt(const APInt &api);
void initFromFloat8E4M3B11FNUZAPInt(const APInt &api);

void assign(const IEEEFloat &);
void copySignificand(const IEEEFloat &);
void freeSignificand();

/// Note: this must be the first data member.
/// The semantics that this value obeys.
const fltSemantics *semantics;

/// A binary fraction with an explicit integer bit.
///
/// The significand must be at least one bit wider than the target precision.
union Significand {
  integerPart part;
  integerPart *parts;
} significand;

/// The signed unbiased exponent of the value.
ExponentType exponent;

/// What kind of floating point number this is.
///
/// Only 2 bits are required, but VisualStudio incorrectly sign extends it.
/// Using the extra bit keeps it from failing under VisualStudio.
fltCategory category : 3;

/// Sign bit of the number.
unsigned int sign : 1;
650};

652hash_code hash_value(const IEEEFloat &Arg);
653int ilogb(const IEEEFloat &Arg);
654IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
655IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);

657// This mode implements more precise float in terms of two APFloats.
658// The interface and layout is designed for arbitrary underlying semantics,
659// though currently only PPCDoubleDouble semantics are supported, whose
660// corresponding underlying semantics are IEEEdouble.
661class DoubleAPFloat final : public APFloatBase {
// Note: this must be the first data member.
const fltSemantics *Semantics;
std::unique_ptr<APFloat[]> Floats;

opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
                 const APFloat &cc, roundingMode RM);

opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS,
                        DoubleAPFloat &Out, roundingMode RM);

672public:
DoubleAPFloat(const fltSemantics &S);
DoubleAPFloat(const fltSemantics &S, uninitializedTag);
DoubleAPFloat(const fltSemantics &S, integerPart);
DoubleAPFloat(const fltSemantics &S, const APInt &I);
DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second);
DoubleAPFloat(const DoubleAPFloat &RHS);
DoubleAPFloat(DoubleAPFloat &&RHS);

DoubleAPFloat &operator=(const DoubleAPFloat &RHS);

DoubleAPFloat &operator=(DoubleAPFloat &&RHS) {
  if (this != &RHS) {
    this->~DoubleAPFloat();
    new (this) DoubleAPFloat(std::move(RHS));
  }
  return *this;
}

bool needsCleanup() const { return Floats != nullptr; }

APFloat &getFirst() { return Floats[0]; }
const APFloat &getFirst() const { return Floats[0]; }
APFloat &getSecond() { return Floats[1]; }
const APFloat &getSecond() const { return Floats[1]; }

opStatus add(const DoubleAPFloat &RHS, roundingMode RM);
opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM);
opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM);
opStatus divide(const DoubleAPFloat &RHS, roundingMode RM);
opStatus remainder(const DoubleAPFloat &RHS);
opStatus mod(const DoubleAPFloat &RHS);
opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand,
                          const DoubleAPFloat &Addend, roundingMode RM);
opStatus roundToIntegral(roundingMode RM);
void changeSign();
cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const;

fltCategory getCategory() const;
bool isNegative() const;

void makeInf(bool Neg);
void makeZero(bool Neg);
void makeLargest(bool Neg);
void makeSmallest(bool Neg);
void makeSmallestNormalized(bool Neg);
void makeNaN(bool SNaN, bool Neg, const APInt *fill);

cmpResult compare(const DoubleAPFloat &RHS) const;
bool bitwiseIsEqual(const DoubleAPFloat &RHS) const;
APInt bitcastToAPInt() const;
Expected<opStatus> convertFromString(StringRef, roundingMode);
opStatus next(bool nextDown);

opStatus convertToInteger(MutableArrayRef<integerPart> Input,
                          unsigned int Width, bool IsSigned, roundingMode RM,
                          bool *IsExact) const;
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM);
opStatus convertFromSignExtendedInteger(const integerPart *Input,
                                        unsigned int InputSize, bool IsSigned,
                                        roundingMode RM);
opStatus convertFromZeroExtendedInteger(const integerPart *Input,
                                        unsigned int InputSize, bool IsSigned,
                                        roundingMode RM);
unsigned int convertToHexString(char *DST, unsigned int HexDigits,
                                bool UpperCase, roundingMode RM) const;

bool isDenormal() const;
bool isSmallest() const;
bool isSmallestNormalized() const;
bool isLargest() const;
bool isInteger() const;

void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
              unsigned FormatMaxPadding, bool TruncateZero = true) const;

bool getExactInverse(APFloat *inv) const;

friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp, roundingMode);
friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode);
friend hash_code hash_value(const DoubleAPFloat &Arg);
753};

755hash_code hash_value(const DoubleAPFloat &Arg);

757} // End detail namespace

759// This is a interface class that is currently forwarding functionalities from
760// detail::IEEEFloat.
761class APFloat : public APFloatBase {
typedef detail::IEEEFloat IEEEFloat;
typedef detail::DoubleAPFloat DoubleAPFloat;

static_assert(std::is_standard_layout<IEEEFloat>::value);

union Storage {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
  DoubleAPFloat Double;

  explicit Storage(IEEEFloat F, const fltSemantics &S);
  explicit Storage(DoubleAPFloat F, const fltSemantics &S)
      : Double(std::move(F)) {
    assert(&S == &PPCDoubleDouble())(static_cast <bool> (&S == &PPCDoubleDouble()) ?
 void (0) : __assert_fail ("&S == &PPCDoubleDouble()"
, "llvm/include/llvm/ADT/APFloat.h", 775, __extension__ __PRETTY_FUNCTION__
));
  }

  template <typename... ArgTypes>
  Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
    if (usesLayout<IEEEFloat>(Semantics)) {
      new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
      return;
    }
    if (usesLayout<DoubleAPFloat>(Semantics)) {
      new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
      return;
    }
    llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 788);
  }

  ~Storage() {
    if (usesLayout<IEEEFloat>(*semantics)) {
      IEEE.~IEEEFloat();
      return;
    }
    if (usesLayout<DoubleAPFloat>(*semantics)) {
      Double.~DoubleAPFloat();
      return;
    }
    llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 800);
  }

  Storage(const Storage &RHS) {
    if (usesLayout<IEEEFloat>(*RHS.semantics)) {
7
←
Assuming the condition is false→
8
←
Taking false branch→
      new (this) IEEEFloat(RHS.IEEE);
      return;
    }
    if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
9
←
Assuming the condition is true→
10
←
Taking true branch→
      new (this) DoubleAPFloat(RHS.Double);
11
←
Calling copy constructor for 'DoubleAPFloat'→
16
←
Returning from copy constructor for 'DoubleAPFloat'→
      return;
    }
    llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 812);
  }

  Storage(Storage &&RHS) {
    if (usesLayout<IEEEFloat>(*RHS.semantics)) {
      new (this) IEEEFloat(std::move(RHS.IEEE));
      return;
    }
    if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
      new (this) DoubleAPFloat(std::move(RHS.Double));
      return;
    }
    llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 824);
  }

  Storage &operator=(const Storage &RHS) {
    if (usesLayout<IEEEFloat>(*semantics) &&
        usesLayout<IEEEFloat>(*RHS.semantics)) {
      IEEE = RHS.IEEE;
    } else if (usesLayout<DoubleAPFloat>(*semantics) &&
               usesLayout<DoubleAPFloat>(*RHS.semantics)) {
      Double = RHS.Double;
    } else if (this != &RHS) {
      this->~Storage();
      new (this) Storage(RHS);
    }
    return *this;
  }

  Storage &operator=(Storage &&RHS) {
    if (usesLayout<IEEEFloat>(*semantics) &&
        usesLayout<IEEEFloat>(*RHS.semantics)) {
      IEEE = std::move(RHS.IEEE);
    } else if (usesLayout<DoubleAPFloat>(*semantics) &&
               usesLayout<DoubleAPFloat>(*RHS.semantics)) {
      Double = std::move(RHS.Double);
    } else if (this != &RHS) {
      this->~Storage();
      new (this) Storage(std::move(RHS));
    }
    return *this;
  }
} U;

template <typename T> static bool usesLayout(const fltSemantics &Semantics) {
  static_assert(std::is_same<T, IEEEFloat>::value ||
                std::is_same<T, DoubleAPFloat>::value);
  if (std::is_same<T, DoubleAPFloat>::value) {
    return &Semantics == &PPCDoubleDouble();
  }
  return &Semantics != &PPCDoubleDouble();
}

IEEEFloat &getIEEE() {
  if (usesLayout<IEEEFloat>(*U.semantics))
    return U.IEEE;
  if (usesLayout<DoubleAPFloat>(*U.semantics))
    return U.Double.getFirst().U.IEEE;
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 870);
}

const IEEEFloat &getIEEE() const {
  if (usesLayout<IEEEFloat>(*U.semantics))
    return U.IEEE;
  if (usesLayout<DoubleAPFloat>(*U.semantics))
    return U.Double.getFirst().U.IEEE;
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 878);
}

void makeZero(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeZero(Neg)); }

void makeInf(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeInf(Neg)); }

void makeNaN(bool SNaN, bool Neg, const APInt *fill) {
  APFLOAT_DISPATCH_ON_SEMANTICS(makeNaN(SNaN, Neg, fill));
}

void makeLargest(bool Neg) {
  APFLOAT_DISPATCH_ON_SEMANTICS(makeLargest(Neg));
}

void makeSmallest(bool Neg) {
  APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg));
}

void makeSmallestNormalized(bool Neg) {
  APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallestNormalized(Neg));
}

explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {}
explicit APFloat(DoubleAPFloat F, const fltSemantics &S)
    : U(std::move(F), S) {}

cmpResult compareAbsoluteValue(const APFloat &RHS) const {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only compare APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only compare APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 907, __extension__ __PRETTY_FUNCTION__
))
         "Should only compare APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only compare APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only compare APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 907, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.compareAbsoluteValue(RHS.U.Double);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 912);
}

915public:
APFloat(const fltSemantics &Semantics) : U(Semantics) {}
APFloat(const fltSemantics &Semantics, StringRef S);
APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {}
template <typename T,
          typename = std::enable_if_t<std::is_floating_point<T>::value>>
APFloat(const fltSemantics &Semantics, T V) = delete;
// TODO: Remove this constructor. This isn't faster than the first one.
APFloat(const fltSemantics &Semantics, uninitializedTag)
    : U(Semantics, uninitialized) {}
APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
APFloat(const APFloat &RHS) = default;
6
←
Calling copy constructor for 'Storage'→
17
←
Returning from copy constructor for 'Storage'→
APFloat(APFloat &&RHS) = default;

~APFloat() = default;

bool needsCleanup() const { APFLOAT_DISPATCH_ON_SEMANTICS(needsCleanup()); }

/// Factory for Positive and Negative Zero.
///
/// \param Negative True iff the number should be negative.
static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
  APFloat Val(Sem, uninitialized);
  Val.makeZero(Negative);
  return Val;
}

/// Factory for Positive and Negative Infinity.
///
/// \param Negative True iff the number should be negative.
static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
  APFloat Val(Sem, uninitialized);
  Val.makeInf(Negative);
  return Val;
}

/// Factory for NaN values.
///
/// \param Negative - True iff the NaN generated should be negative.
/// \param payload - The unspecified fill bits for creating the NaN, 0 by
/// default.  The value is truncated as necessary.
static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
                      uint64_t payload = 0) {
  if (payload) {
    APInt intPayload(64, payload);
    return getQNaN(Sem, Negative, &intPayload);
  } else {
    return getQNaN(Sem, Negative, nullptr);
  }
}

/// Factory for QNaN values.
static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
                       const APInt *payload = nullptr) {
  APFloat Val(Sem, uninitialized);
  Val.makeNaN(false, Negative, payload);
  return Val;
}

/// Factory for SNaN values.
static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
                       const APInt *payload = nullptr) {
  APFloat Val(Sem, uninitialized);
  Val.makeNaN(true, Negative, payload);
  return Val;
}

/// Returns the largest finite number in the given semantics.
///
/// \param Negative - True iff the number should be negative
static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) {
  APFloat Val(Sem, uninitialized);
  Val.makeLargest(Negative);
  return Val;
}

/// Returns the smallest (by magnitude) finite number in the given semantics.
/// Might be denormalized, which implies a relative loss of precision.
///
/// \param Negative - True iff the number should be negative
static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) {
  APFloat Val(Sem, uninitialized);
  Val.makeSmallest(Negative);
  return Val;
}

/// Returns the smallest (by magnitude) normalized finite number in the given
/// semantics.
///
/// \param Negative - True iff the number should be negative
static APFloat getSmallestNormalized(const fltSemantics &Sem,
                                     bool Negative = false) {
  APFloat Val(Sem, uninitialized);
  Val.makeSmallestNormalized(Negative);
  return Val;
}

/// Returns a float which is bitcasted from an all one value int.
///
/// \param Semantics - type float semantics
static APFloat getAllOnesValue(const fltSemantics &Semantics);

/// Used to insert APFloat objects, or objects that contain APFloat objects,
/// into FoldingSets.
void Profile(FoldingSetNodeID &NID) const;

opStatus add(const APFloat &RHS, roundingMode RM) {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1025, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on two APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1025, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.add(RHS.U.IEEE, RM);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.add(RHS.U.Double, RM);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1030);
}
opStatus subtract(const APFloat &RHS, roundingMode RM) {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1034, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on two APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1034, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.subtract(RHS.U.IEEE, RM);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.subtract(RHS.U.Double, RM);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1039);
}
opStatus multiply(const APFloat &RHS, roundingMode RM) {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1043, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on two APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1043, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.multiply(RHS.U.IEEE, RM);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.multiply(RHS.U.Double, RM);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1048);
}
opStatus divide(const APFloat &RHS, roundingMode RM) {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1052, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on two APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1052, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.divide(RHS.U.IEEE, RM);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.divide(RHS.U.Double, RM);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1057);
}
opStatus remainder(const APFloat &RHS) {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1061, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on two APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1061, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.remainder(RHS.U.IEEE);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.remainder(RHS.U.Double);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1066);
}
opStatus mod(const APFloat &RHS) {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1070, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on two APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only call on two APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only call on two APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1070, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.mod(RHS.U.IEEE);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.mod(RHS.U.Double);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1075);
}
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
                          roundingMode RM) {
  assert(&getSemantics() == &Multiplicand.getSemantics() &&(static_cast <bool> (&getSemantics() == &Multiplicand
.getSemantics() && "Should only call on APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &Multiplicand.getSemantics() && \"Should only call on APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1080, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &Multiplicand
.getSemantics() && "Should only call on APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &Multiplicand.getSemantics() && \"Should only call on APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1080, __extension__ __PRETTY_FUNCTION__
));
  assert(&getSemantics() == &Addend.getSemantics() &&(static_cast <bool> (&getSemantics() == &Addend
.getSemantics() && "Should only call on APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &Addend.getSemantics() && \"Should only call on APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1082, __extension__ __PRETTY_FUNCTION__
))
         "Should only call on APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &Addend
.getSemantics() && "Should only call on APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &Addend.getSemantics() && \"Should only call on APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1082, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
                                     RM);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1088);
}
opStatus roundToIntegral(roundingMode RM) {
  APFLOAT_DISPATCH_ON_SEMANTICS(roundToIntegral(RM));
}

// TODO: bool parameters are not readable and a source of bugs.
// Do something.
opStatus next(bool nextDown) {
  APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown));
}

/// Negate an APFloat.
APFloat operator-() const {
  APFloat Result(*this);
  Result.changeSign();
  return Result;
}

/// Add two APFloats, rounding ties to the nearest even.
/// No error checking.
APFloat operator+(const APFloat &RHS) const {
  APFloat Result(*this);
  (void)Result.add(RHS, rmNearestTiesToEven);
  return Result;
}

/// Subtract two APFloats, rounding ties to the nearest even.
/// No error checking.
APFloat operator-(const APFloat &RHS) const {
  APFloat Result(*this);
  (void)Result.subtract(RHS, rmNearestTiesToEven);
  return Result;
}

/// Multiply two APFloats, rounding ties to the nearest even.
/// No error checking.
APFloat operator*(const APFloat &RHS) const {
  APFloat Result(*this);
  (void)Result.multiply(RHS, rmNearestTiesToEven);
  return Result;
}

/// Divide the first APFloat by the second, rounding ties to the nearest even.
/// No error checking.
APFloat operator/(const APFloat &RHS) const {
  APFloat Result(*this);
  (void)Result.divide(RHS, rmNearestTiesToEven);
  return Result;
}

void changeSign() { APFLOAT_DISPATCH_ON_SEMANTICS(changeSign()); }
void clearSign() {
  if (isNegative())
    changeSign();
}
void copySign(const APFloat &RHS) {
  if (isNegative() != RHS.isNegative())
    changeSign();
}

/// A static helper to produce a copy of an APFloat value with its sign
/// copied from some other APFloat.
static APFloat copySign(APFloat Value, const APFloat &Sign) {
  Value.copySign(Sign);
  return Value;
}

/// Assuming this is an IEEE-754 NaN value, quiet its signaling bit.
/// This preserves the sign and payload bits.
APFloat makeQuiet() const {
  APFloat Result(*this);
  Result.getIEEE().makeQuiet();
  return Result;
}

opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
                 bool *losesInfo);
opStatus convertToInteger(MutableArrayRef<integerPart> Input,
                          unsigned int Width, bool IsSigned, roundingMode RM,
                          bool *IsExact) const {
  APFLOAT_DISPATCH_ON_SEMANTICS(
      convertToInteger(Input, Width, IsSigned, RM, IsExact));
}
opStatus convertToInteger(APSInt &Result, roundingMode RM,
                          bool *IsExact) const;
opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
                          roundingMode RM) {
  APFLOAT_DISPATCH_ON_SEMANTICS(convertFromAPInt(Input, IsSigned, RM));
}
opStatus convertFromSignExtendedInteger(const integerPart *Input,
                                        unsigned int InputSize, bool IsSigned,
                                        roundingMode RM) {
  APFLOAT_DISPATCH_ON_SEMANTICS(
      convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM));
}
opStatus convertFromZeroExtendedInteger(const integerPart *Input,
                                        unsigned int InputSize, bool IsSigned,
                                        roundingMode RM) {
  APFLOAT_DISPATCH_ON_SEMANTICS(
      convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM));
}
Expected<opStatus> convertFromString(StringRef, roundingMode);
APInt bitcastToAPInt() const {
  APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt());
}

/// Converts this APFloat to host double value.
///
/// \pre The APFloat must be built using semantics, that can be represented by
/// the host double type without loss of precision. It can be IEEEdouble and
/// shorter semantics, like IEEEsingle and others.
double convertToDouble() const;

/// Converts this APFloat to host float value.
///
/// \pre The APFloat must be built using semantics, that can be represented by
/// the host float type without loss of precision. It can be IEEEsingle and
/// shorter semantics, like IEEEhalf.
float convertToFloat() const;

bool operator==(const APFloat &RHS) const { return compare(RHS) == cmpEqual; }

bool operator!=(const APFloat &RHS) const { return compare(RHS) != cmpEqual; }

bool operator<(const APFloat &RHS) const {
  return compare(RHS) == cmpLessThan;
}

bool operator>(const APFloat &RHS) const {
  return compare(RHS) == cmpGreaterThan;
}

bool operator<=(const APFloat &RHS) const {
  cmpResult Res = compare(RHS);
  return Res == cmpLessThan || Res == cmpEqual;
}

bool operator>=(const APFloat &RHS) const {
  cmpResult Res = compare(RHS);
  return Res == cmpGreaterThan || Res == cmpEqual;
}

cmpResult compare(const APFloat &RHS) const {
  assert(&getSemantics() == &RHS.getSemantics() &&(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only compare APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only compare APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1233, __extension__ __PRETTY_FUNCTION__
))
         "Should only compare APFloats with the same semantics")(static_cast <bool> (&getSemantics() == &RHS.getSemantics
() && "Should only compare APFloats with the same semantics"
) ? void (0) : __assert_fail ("&getSemantics() == &RHS.getSemantics() && \"Should only compare APFloats with the same semantics\""
, "llvm/include/llvm/ADT/APFloat.h", 1233, __extension__ __PRETTY_FUNCTION__
));
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.compare(RHS.U.IEEE);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.compare(RHS.U.Double);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1238);
}

bool bitwiseIsEqual(const APFloat &RHS) const {
  if (&getSemantics() != &RHS.getSemantics())
    return false;
  if (usesLayout<IEEEFloat>(getSemantics()))
    return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
  if (usesLayout<DoubleAPFloat>(getSemantics()))
    return U.Double.bitwiseIsEqual(RHS.U.Double);
  llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1248);
}

/// We don't rely on operator== working on double values, as
/// it returns true for things that are clearly not equal, like -0.0 and 0.0.
/// As such, this method can be used to do an exact bit-for-bit comparison of
/// two floating point values.
///
/// We leave the version with the double argument here because it's just so
/// convenient to write "2.0" and the like.  Without this function we'd
/// have to duplicate its logic everywhere it's called.
bool isExactlyValue(double V) const {
  bool ignored;
  APFloat Tmp(V);
  Tmp.convert(getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
  return bitwiseIsEqual(Tmp);
}

unsigned int convertToHexString(char *DST, unsigned int HexDigits,
                                bool UpperCase, roundingMode RM) const {
  APFLOAT_DISPATCH_ON_SEMANTICS(
      convertToHexString(DST, HexDigits, UpperCase, RM));
}

bool isZero() const { return getCategory() == fcZero; }
bool isInfinity() const { return getCategory() == fcInfinity; }
bool isNaN() const { return getCategory() == fcNaN; }

bool isNegative() const { return getIEEE().isNegative(); }
bool isDenormal() const { APFLOAT_DISPATCH_ON_SEMANTICS(isDenormal()); }
bool isSignaling() const { return getIEEE().isSignaling(); }

bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
bool isFinite() const { return !isNaN() && !isInfinity(); }

fltCategory getCategory() const { return getIEEE().getCategory(); }
const fltSemantics &getSemantics() const { return *U.semantics; }
bool isNonZero() const { return !isZero(); }
bool isFiniteNonZero() const { return isFinite() && !isZero(); }
bool isPosZero() const { return isZero() && !isNegative(); }
bool isNegZero() const { return isZero() && isNegative(); }
bool isPosInfinity() const { return isInfinity() && !isNegative(); }
bool isNegInfinity() const { return isInfinity() && isNegative(); }
bool isSmallest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isSmallest()); }
bool isLargest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isLargest()); }
bool isInteger() const { APFLOAT_DISPATCH_ON_SEMANTICS(isInteger()); }
bool isIEEE() const { return usesLayout<IEEEFloat>(getSemantics()); }

bool isSmallestNormalized() const {
  APFLOAT_DISPATCH_ON_SEMANTICS(isSmallestNormalized());
}

/// Return the FPClassTest which will return true for the value.
FPClassTest classify() const;

APFloat &operator=(const APFloat &RHS) = default;
APFloat &operator=(APFloat &&RHS) = default;

void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
              unsigned FormatMaxPadding = 3, bool TruncateZero = true) const {
  APFLOAT_DISPATCH_ON_SEMANTICS(
      toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero));
}

void print(raw_ostream &) const;
void dump() const;

bool getExactInverse(APFloat *inv) const {
  APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
}

friend hash_code hash_value(const APFloat &Arg);
friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
friend IEEEFloat;
friend DoubleAPFloat;
1325};

1327/// See friend declarations above.
1328///
1329/// These additional declarations are required in order to compile LLVM with IBM
1330/// xlC compiler.
1331hash_code hash_value(const APFloat &Arg);
1332inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
  return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
  return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics());
llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1337);
1338}

1340/// Equivalent of C standard library function.
1341///
1342/// While the C standard says Exp is an unspecified value for infinity and nan,
1343/// this returns INT_MAX for infinities, and INT_MIN for NaNs.
1344inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
  return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics());
if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
  return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics());
llvm_unreachable("Unexpected semantics")::llvm::llvm_unreachable_internal("Unexpected semantics", "llvm/include/llvm/ADT/APFloat.h"
, 1349);
1350}
1351/// Returns the absolute value of the argument.
1352inline APFloat abs(APFloat X) {
X.clearSign();
return X;
1355}

1357/// Returns the negated value of the argument.
1358inline APFloat neg(APFloat X) {
X.changeSign();
return X;
1361}

1363/// Implements IEEE minNum semantics. Returns the smaller of the 2 arguments if
1364/// both are not NaN. If either argument is a NaN, returns the other argument.
1365LLVM_READONLY__attribute__((__pure__))
1366inline APFloat minnum(const APFloat &A, const APFloat &B) {
if (A.isNaN())
  return B;
if (B.isNaN())
  return A;
return B < A ? B : A;
1372}

1374/// Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if
1375/// both are not NaN. If either argument is a NaN, returns the other argument.
1376LLVM_READONLY__attribute__((__pure__))
1377inline APFloat maxnum(const APFloat &A, const APFloat &B) {
if (A.isNaN())
  return B;
if (B.isNaN())
  return A;
return A < B ? B : A;
1383}

1385/// Implements IEEE 754-2018 minimum semantics. Returns the smaller of 2
1386/// arguments, propagating NaNs and treating -0 as less than +0.
1387LLVM_READONLY__attribute__((__pure__))
1388inline APFloat minimum(const APFloat &A, const APFloat &B) {
if (A.isNaN())
  return A;
if (B.isNaN())
  return B;
if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))
  return A.isNegative() ? A : B;
return B < A ? B : A;
1396}

1398/// Implements IEEE 754-2018 maximum semantics. Returns the larger of 2
1399/// arguments, propagating NaNs and treating -0 as less than +0.
1400LLVM_READONLY__attribute__((__pure__))
1401inline APFloat maximum(const APFloat &A, const APFloat &B) {
if (A.isNaN())
  return A;
if (B.isNaN())
  return B;
if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))
  return A.isNegative() ? B : A;
return A < B ? B : A;
1409}

1411} // namespace llvm

1413#undef APFLOAT_DISPATCH_ON_SEMANTICS
1414#endif // LLVM_ADT_APFLOAT_H