/build/source/flang/include/flang/Evaluate/integer.h

Bug Summary

File:	build/source/flang/include/flang/Evaluate/integer.h
Warning:	line 471, column 28 The result of the left shift is undefined due to shifting '-1' by '32', which is unrepresentable in the unsigned version of the return type 'unsigned long'

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 real.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 -relaxed-aliasing -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 -isystem /build/source/llvm/../mlir/include -isystem tools/mlir/include -isystem tools/clang/include -isystem /build/source/llvm/../clang/include -D FLANG_INCLUDE_TESTS=1 -D FLANG_LITTLE_ENDIAN=1 -D FLANG_VENDOR="Debian " -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 tools/flang/unittests/Evaluate -I /build/source/flang/unittests/Evaluate -I /build/source/flang/include -I tools/flang/include -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 -Wno-deprecated-copy -Wno-ctad-maybe-unsupported -Wno-suggest-override -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 -fcxx-exceptions -fexceptions -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/flang/unittests/Evaluate/real.cpp

/build/source/flang/unittests/Evaluate/real.cpp

→

1#include "fp-testing.h"
2#include "testing.h"
3#include "flang/Evaluate/type.h"
4#include "llvm/Support/raw_ostream.h"
5#include <cmath>
6#include <cstdio>
7#include <cstdlib>
8#include <type_traits>
9 
10using namespace Fortran::evaluate;
11using namespace Fortran::common;
12 
13using Real2 = Scalar<Type<TypeCategory::Real, 2>>;
14using Real3 = Scalar<Type<TypeCategory::Real, 3>>;
15using Real4 = Scalar<Type<TypeCategory::Real, 4>>;
16using Real8 = Scalar<Type<TypeCategory::Real, 8>>;
17using Real10 = Scalar<Type<TypeCategory::Real, 10>>;
18using Real16 = Scalar<Type<TypeCategory::Real, 16>>;
19using Integer4 = Scalar<Type<TypeCategory::Integer, 4>>;
20using Integer8 = Scalar<Type<TypeCategory::Integer, 8>>;
21 
22void dumpTest() {
23  struct {
24    std::uint64_t raw;
25    const char *expected;
26  } table[] = {
27      {0x7f876543, "NaN0x7f876543"},
28      {0x7f800000, "Inf"},
29      {0xff800000, "-Inf"},
30      {0x00000000, "0.0"},
31      {0x80000000, "-0.0"},
32      {0x3f800000, "0x1.0p0"},
33      {0xbf800000, "-0x1.0p0"},
34      {0x40000000, "0x1.0p1"},
35      {0x3f000000, "0x1.0p-1"},
36      {0x7f7fffff, "0x1.fffffep127"},
37      {0x00800000, "0x1.0p-126"},
38      {0x00400000, "0x0.8p-126"},
39      {0x00000001, "0x0.000002p-126"},
40      {0, nullptr},
41  };
42  for (int j{0}; table[j].expected != nullptr; ++j) {
43    TEST(Real4{Integer4{table[j].raw}}.DumpHexadecimal() == table[j].expected)testing::Test("flang/unittests/Evaluate/real.cpp", 43, "Real4{Integer4{table[j].raw}}.DumpHexadecimal() == table[j].expected"
, (Real4{Integer4{table[j].raw}}.DumpHexadecimal() == table[j
].expected))
44    ("%d", j);
45  }
46}
47 
48template <typename R> void basicTests(int rm, Rounding rounding) {
49  static constexpr int kind{R::bits / 8};
50  char desc[64];
51  using Word = typename R::Word;
52  std::snprintf(desc, sizeof desc, "bits=%d, le=%d, kind=%d", R::bits,
53      Word::littleEndian, kind);
54  R zero;
55  TEST(!zero.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 55, "!zero.IsNegative()"
, (!zero.IsNegative()))(desc);
56  TEST(!zero.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 56, "!zero.IsNotANumber()"
, (!zero.IsNotANumber()))(desc);
57  TEST(!zero.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 57, "!zero.IsInfinite()"
, (!zero.IsInfinite()))(desc);
58  TEST(zero.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 58, "zero.IsZero()"
, (zero.IsZero()))(desc);
59  MATCH(0, zero.Exponent())testing::Match("flang/unittests/Evaluate/real.cpp", 59, (0), "zero.Exponent()"
, (zero.Exponent()))(desc);
60  TEST(zero.RawBits().IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 60, "zero.RawBits().IsZero()"
, (zero.RawBits().IsZero()))(desc);
61  MATCH(0, zero.RawBits().ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 61, (0), "zero.RawBits().ToUInt64()"
, (zero.RawBits().ToUInt64()))(desc);
62  TEST(zero.ABS().RawBits().IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 62, "zero.ABS().RawBits().IsZero()"
, (zero.ABS().RawBits().IsZero()))(desc);
63  TEST(zero.Negate().RawBits().IEOR(Word::MASKL(1)).IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 63, "zero.Negate().RawBits().IEOR(Word::MASKL(1)).IsZero()"
, (zero.Negate().RawBits().IEOR(Word::MASKL(1)).IsZero()))(desc);
64  TEST(zero.Compare(zero) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 64, "zero.Compare(zero) == Relation::Equal"
, (zero.Compare(zero) == Relation::Equal))(desc);
1
Assuming the condition is false→
65  R minusZero{Word{std::uint64_t{1}}.SHIFTL(R::bits - 1)};
66  TEST(minusZero.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 66, "minusZero.IsNegative()"
, (minusZero.IsNegative()))(desc);
67  TEST(!minusZero.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 67, "!minusZero.IsNotANumber()"
, (!minusZero.IsNotANumber()))(desc);
68  TEST(!minusZero.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 68, "!minusZero.IsInfinite()"
, (!minusZero.IsInfinite()))(desc);
69  TEST(minusZero.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 69, "minusZero.IsZero()"
, (minusZero.IsZero()))(desc);
70  TEST(minusZero.ABS().RawBits().IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 70, "minusZero.ABS().RawBits().IsZero()"
, (minusZero.ABS().RawBits().IsZero()))(desc);
71  TEST(minusZero.Negate().RawBits().IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 71, "minusZero.Negate().RawBits().IsZero()"
, (minusZero.Negate().RawBits().IsZero()))(desc);
72  MATCH(0, minusZero.Exponent())testing::Match("flang/unittests/Evaluate/real.cpp", 72, (0), "minusZero.Exponent()"
, (minusZero.Exponent()))(desc);
73  MATCH(0, minusZero.RawBits().LEADZ())testing::Match("flang/unittests/Evaluate/real.cpp", 73, (0), "minusZero.RawBits().LEADZ()"
, (minusZero.RawBits().LEADZ()))(desc);
74  MATCH(1, minusZero.RawBits().POPCNT())testing::Match("flang/unittests/Evaluate/real.cpp", 74, (1), "minusZero.RawBits().POPCNT()"
, (minusZero.RawBits().POPCNT()))(desc);
75  TEST(minusZero.Compare(minusZero) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 75, "minusZero.Compare(minusZero) == Relation::Equal"
, (minusZero.Compare(minusZero) == Relation::Equal))(desc);
2
←
Assuming the condition is false→
76  TEST(zero.Compare(minusZero) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 76, "zero.Compare(minusZero) == Relation::Equal"
, (zero.Compare(minusZero) == Relation::Equal))(desc);
3
←
Assuming the condition is false→
77  ValueWithRealFlags<R> vr;
78  MATCH(0, vr.value.RawBits().ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 78, (0), "vr.value.RawBits().ToUInt64()"
, (vr.value.RawBits().ToUInt64()))(desc);
79  TEST(vr.flags.empty())testing::Test("flang/unittests/Evaluate/real.cpp", 79, "vr.flags.empty()"
, (vr.flags.empty()))(desc);
80  R nan{Word{std::uint64_t{1}}
81            .SHIFTL(R::bits)
82            .SubtractSigned(Word{std::uint64_t{1}})
83            .value};
84  MATCH(R::bits, nan.RawBits().POPCNT())testing::Match("flang/unittests/Evaluate/real.cpp", 84, (R::bits
), "nan.RawBits().POPCNT()", (nan.RawBits().POPCNT()))(desc);
85  TEST(!nan.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 85, "!nan.IsNegative()"
, (!nan.IsNegative()))(desc);
86  TEST(nan.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 86, "nan.IsNotANumber()"
, (nan.IsNotANumber()))(desc);
87  TEST(!nan.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 87, "!nan.IsInfinite()"
, (!nan.IsInfinite()))(desc);
88  TEST(!nan.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 88, "!nan.IsZero()"
, (!nan.IsZero()))(desc);
89  TEST(zero.Compare(nan) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 89, "zero.Compare(nan) == Relation::Unordered"
, (zero.Compare(nan) == Relation::Unordered))(desc);
4
←
Assuming the condition is false→
90  TEST(minusZero.Compare(nan) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 90, "minusZero.Compare(nan) == Relation::Unordered"
, (minusZero.Compare(nan) == Relation::Unordered))(desc);
5
←
Assuming the condition is false→
91  TEST(nan.Compare(zero) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 91, "nan.Compare(zero) == Relation::Unordered"
, (nan.Compare(zero) == Relation::Unordered))(desc);
6
←
Assuming the condition is false→
92  TEST(nan.Compare(minusZero) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 92, "nan.Compare(minusZero) == Relation::Unordered"
, (nan.Compare(minusZero) == Relation::Unordered))(desc);
7
←
Assuming the condition is false→
93  TEST(nan.Compare(nan) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 93, "nan.Compare(nan) == Relation::Unordered"
, (nan.Compare(nan) == Relation::Unordered))(desc);
8
←
Assuming the condition is false→
94  int significandBits{R::binaryPrecision - R::isImplicitMSB};
95  int exponentBits{R::bits - significandBits - 1};
96  std::uint64_t maxExponent{(std::uint64_t{1} << exponentBits) - 1};
97  MATCH(nan.Exponent(), maxExponent)testing::Match("flang/unittests/Evaluate/real.cpp", 97, (nan.
Exponent()), "maxExponent", (maxExponent))(desc);
98  R inf{Word{maxExponent}.SHIFTL(significandBits)};
99  TEST(!inf.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 99, "!inf.IsNegative()"
, (!inf.IsNegative()))(desc);
9
←
Assuming the condition is false→
100  TEST(!inf.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 100, "!inf.IsNotANumber()"
, (!inf.IsNotANumber()))(desc);
101  TEST(inf.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 101, "inf.IsInfinite()"
, (inf.IsInfinite()))(desc);
102  TEST(!inf.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 102, "!inf.IsZero()"
, (!inf.IsZero()))(desc);
103  TEST(inf.RawBits().CompareUnsigned(inf.ABS().RawBits()) == Ordering::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 103, "inf.RawBits().CompareUnsigned(inf.ABS().RawBits()) == Ordering::Equal"
, (inf.RawBits().CompareUnsigned(inf.ABS().RawBits()) == Ordering
::Equal))
104  (desc);
105  TEST(zero.Compare(inf) == Relation::Less)testing::Test("flang/unittests/Evaluate/real.cpp", 105, "zero.Compare(inf) == Relation::Less"
, (zero.Compare(inf) == Relation::Less))(desc);
10
←
Assuming the condition is false→
106  TEST(minusZero.Compare(inf) == Relation::Less)testing::Test("flang/unittests/Evaluate/real.cpp", 106, "minusZero.Compare(inf) == Relation::Less"
, (minusZero.Compare(inf) == Relation::Less))(desc);
11
←
Assuming the condition is false→
107  TEST(nan.Compare(inf) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 107, "nan.Compare(inf) == Relation::Unordered"
, (nan.Compare(inf) == Relation::Unordered))(desc);
12
←
Assuming the condition is false→
108  TEST(inf.Compare(inf) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 108, "inf.Compare(inf) == Relation::Equal"
, (inf.Compare(inf) == Relation::Equal))(desc);
13
←
Assuming the condition is false→
109  R negInf{Word{maxExponent}.SHIFTL(significandBits).IOR(Word::MASKL(1))};
110  TEST(negInf.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 110, "negInf.IsNegative()"
, (negInf.IsNegative()))(desc);
111  TEST(!negInf.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 111, "!negInf.IsNotANumber()"
, (!negInf.IsNotANumber()))(desc);
112  TEST(negInf.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 112, "negInf.IsInfinite()"
, (negInf.IsInfinite()))(desc);
113  TEST(!negInf.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 113, "!negInf.IsZero()"
, (!negInf.IsZero()))(desc);
114  TEST(inf.RawBits().CompareUnsigned(negInf.ABS().RawBits()) == Ordering::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 114, "inf.RawBits().CompareUnsigned(negInf.ABS().RawBits()) == Ordering::Equal"
, (inf.RawBits().CompareUnsigned(negInf.ABS().RawBits()) == Ordering
::Equal))
14
←
Assuming the condition is false→
115  (desc);
116  TEST(inf.RawBits().CompareUnsigned(negInf.Negate().RawBits()) ==testing::Test("flang/unittests/Evaluate/real.cpp", 117, "inf.RawBits().CompareUnsigned(negInf.Negate().RawBits()) == Ordering::Equal"
, (inf.RawBits().CompareUnsigned(negInf.Negate().RawBits()) ==
 Ordering::Equal))
15
←
Assuming the condition is false→
117      Ordering::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 117, "inf.RawBits().CompareUnsigned(negInf.Negate().RawBits()) == Ordering::Equal"
, (inf.RawBits().CompareUnsigned(negInf.Negate().RawBits()) ==
 Ordering::Equal))
118  (desc);
119  TEST(inf.Negate().RawBits().CompareUnsigned(negInf.RawBits()) ==testing::Test("flang/unittests/Evaluate/real.cpp", 120, "inf.Negate().RawBits().CompareUnsigned(negInf.RawBits()) == Ordering::Equal"
, (inf.Negate().RawBits().CompareUnsigned(negInf.RawBits()) ==
 Ordering::Equal))
16
←
Assuming the condition is false→
120      Ordering::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 120, "inf.Negate().RawBits().CompareUnsigned(negInf.RawBits()) == Ordering::Equal"
, (inf.Negate().RawBits().CompareUnsigned(negInf.RawBits()) ==
 Ordering::Equal))
121  (desc);
122  TEST(zero.Compare(negInf) == Relation::Greater)testing::Test("flang/unittests/Evaluate/real.cpp", 122, "zero.Compare(negInf) == Relation::Greater"
, (zero.Compare(negInf) == Relation::Greater))(desc);
17
←
Assuming the condition is false→
123  TEST(minusZero.Compare(negInf) == Relation::Greater)testing::Test("flang/unittests/Evaluate/real.cpp", 123, "minusZero.Compare(negInf) == Relation::Greater"
, (minusZero.Compare(negInf) == Relation::Greater))(desc);
18
←
Assuming the condition is false→
124  TEST(nan.Compare(negInf) == Relation::Unordered)testing::Test("flang/unittests/Evaluate/real.cpp", 124, "nan.Compare(negInf) == Relation::Unordered"
, (nan.Compare(negInf) == Relation::Unordered))(desc);
19
←
Assuming the condition is false→
125  TEST(inf.Compare(negInf) == Relation::Greater)testing::Test("flang/unittests/Evaluate/real.cpp", 125, "inf.Compare(negInf) == Relation::Greater"
, (inf.Compare(negInf) == Relation::Greater))(desc);
20
←
Assuming the condition is false→
126  TEST(negInf.Compare(negInf) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 126, "negInf.Compare(negInf) == Relation::Equal"
, (negInf.Compare(negInf) == Relation::Equal))(desc);
21
←
Assuming the condition is false→
127  for (std::uint64_t j{0}; j < 63; ++j) {
22
←
Loop condition is true.  Entering loop body→
128    char ldesc[128];
129    std::uint64_t x{1};
130    x <<= j;
131    std::snprintf(ldesc, sizeof ldesc, "%s j=%d x=0x%jx rm=%d", desc,
132        static_cast<int>(j), static_cast<std::intmax_t>(x), rm);
133    Integer8 ix{x};
134    TEST(!ix.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 134, "!ix.IsNegative()"
, (!ix.IsNegative()))(ldesc);
135    MATCH(x, ix.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 135, (x),
 "ix.ToUInt64()", (ix.ToUInt64()))(ldesc);
136    vr = R::FromInteger(ix, rounding);
137    TEST(!vr.value.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 137, "!vr.value.IsNegative()"
, (!vr.value.IsNegative()))(ldesc);
23
←
Assuming the condition is false→
138    TEST(!vr.value.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 138, "!vr.value.IsNotANumber()"
, (!vr.value.IsNotANumber()))(ldesc);
139    TEST(!vr.value.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 139, "!vr.value.IsZero()"
, (!vr.value.IsZero()))(ldesc);
140    auto ivf = vr.value.template ToInteger<Integer8>();
24
←
Calling 'Real::ToInteger'→
35
←
Returning from 'Real::ToInteger'→
141    if (j > (maxExponent / 2)) {
36
←
Taking false branch→
142      TEST(vr.flags.test(RealFlag::Overflow))testing::Test("flang/unittests/Evaluate/real.cpp", 142, "vr.flags.test(RealFlag::Overflow)"
, (vr.flags.test(RealFlag::Overflow)))(ldesc);
143      TEST(vr.value.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 143, "vr.value.IsInfinite()"
, (vr.value.IsInfinite()))(ldesc);
144      TEST(ivf.flags.test(RealFlag::Overflow))testing::Test("flang/unittests/Evaluate/real.cpp", 144, "ivf.flags.test(RealFlag::Overflow)"
, (ivf.flags.test(RealFlag::Overflow)))(ldesc);
145      MATCH(0x7fffffffffffffff, ivf.value.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 145, (0x7fffffffffffffff
), "ivf.value.ToUInt64()", (ivf.value.ToUInt64()))(ldesc);
146    } else {
147      TEST(vr.flags.empty())testing::Test("flang/unittests/Evaluate/real.cpp", 147, "vr.flags.empty()"
, (vr.flags.empty()))(ldesc);
148      TEST(!vr.value.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 148, "!vr.value.IsInfinite()"
, (!vr.value.IsInfinite()))(ldesc);
149      TEST(ivf.flags.empty())testing::Test("flang/unittests/Evaluate/real.cpp", 149, "ivf.flags.empty()"
, (ivf.flags.empty()))(ldesc);
150      MATCH(x, ivf.value.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 150, (x),
 "ivf.value.ToUInt64()", (ivf.value.ToUInt64()))(ldesc);
37
←
Calling 'Integer::ToUInt64'→
151      if (rounding.mode == RoundingMode::TiesToEven) { // to match stold()
152        std::string buf;
153        llvm::raw_string_ostream ss{buf};
154        vr.value.AsFortran(ss, kind, false /*exact*/);
155        std::string decimal{ss.str()};
156        const char *p{decimal.data()};
157        MATCH(x, static_cast<std::uint64_t>(std::stold(decimal)))testing::Match("flang/unittests/Evaluate/real.cpp", 157, (x),
 "static_cast<std::uint64_t>(std::stold(decimal))", (static_cast
<std::uint64_t>(std::stold(decimal))))
158        ("%s %s", ldesc, p);
159        auto check{R::Read(p, rounding)};
160        auto icheck{check.value.template ToInteger<Integer8>()};
161        MATCH(x, icheck.value.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 161, (x),
 "icheck.value.ToUInt64()", (icheck.value.ToUInt64()))(ldesc);
162        TEST(vr.value.Compare(check.value) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 162, "vr.value.Compare(check.value) == Relation::Equal"
, (vr.value.Compare(check.value) == Relation::Equal))(ldesc);
163      }
164    }
165    TEST(vr.value.ToWholeNumber().value.Compare(vr.value) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 165, "vr.value.ToWholeNumber().value.Compare(vr.value) == Relation::Equal"
, (vr.value.ToWholeNumber().value.Compare(vr.value) == Relation
::Equal))
166    (ldesc);
167    ix = ix.Negate().value;
168    TEST(ix.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 168, "ix.IsNegative()"
, (ix.IsNegative()))(ldesc);
169    x = -x;
170    std::int64_t nx = x;
171    MATCH(x, ix.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 171, (x),
 "ix.ToUInt64()", (ix.ToUInt64()))(ldesc);
172    MATCH(nx, ix.ToInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 172, (nx)
, "ix.ToInt64()", (ix.ToInt64()))(ldesc);
173    vr = R::FromInteger(ix);
174    TEST(vr.value.IsNegative())testing::Test("flang/unittests/Evaluate/real.cpp", 174, "vr.value.IsNegative()"
, (vr.value.IsNegative()))(ldesc);
175    TEST(!vr.value.IsNotANumber())testing::Test("flang/unittests/Evaluate/real.cpp", 175, "!vr.value.IsNotANumber()"
, (!vr.value.IsNotANumber()))(ldesc);
176    TEST(!vr.value.IsZero())testing::Test("flang/unittests/Evaluate/real.cpp", 176, "!vr.value.IsZero()"
, (!vr.value.IsZero()))(ldesc);
177    ivf = vr.value.template ToInteger<Integer8>();
178    if (j > (maxExponent / 2)) {
179      TEST(vr.flags.test(RealFlag::Overflow))testing::Test("flang/unittests/Evaluate/real.cpp", 179, "vr.flags.test(RealFlag::Overflow)"
, (vr.flags.test(RealFlag::Overflow)))(ldesc);
180      TEST(vr.value.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 180, "vr.value.IsInfinite()"
, (vr.value.IsInfinite()))(ldesc);
181      TEST(ivf.flags.test(RealFlag::Overflow))testing::Test("flang/unittests/Evaluate/real.cpp", 181, "ivf.flags.test(RealFlag::Overflow)"
, (ivf.flags.test(RealFlag::Overflow)))(ldesc);
182      MATCH(0x8000000000000000, ivf.value.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 182, (0x8000000000000000
), "ivf.value.ToUInt64()", (ivf.value.ToUInt64()))(ldesc);
183    } else {
184      TEST(vr.flags.empty())testing::Test("flang/unittests/Evaluate/real.cpp", 184, "vr.flags.empty()"
, (vr.flags.empty()))(ldesc);
185      TEST(!vr.value.IsInfinite())testing::Test("flang/unittests/Evaluate/real.cpp", 185, "!vr.value.IsInfinite()"
, (!vr.value.IsInfinite()))(ldesc);
186      TEST(ivf.flags.empty())testing::Test("flang/unittests/Evaluate/real.cpp", 186, "ivf.flags.empty()"
, (ivf.flags.empty()))(ldesc);
187      MATCH(x, ivf.value.ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 187, (x),
 "ivf.value.ToUInt64()", (ivf.value.ToUInt64()))(ldesc);
188      MATCH(nx, ivf.value.ToInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 188, (nx)
, "ivf.value.ToInt64()", (ivf.value.ToInt64()))(ldesc);
189    }
190    TEST(vr.value.ToWholeNumber().value.Compare(vr.value) == Relation::Equal)testing::Test("flang/unittests/Evaluate/real.cpp", 190, "vr.value.ToWholeNumber().value.Compare(vr.value) == Relation::Equal"
, (vr.value.ToWholeNumber().value.Compare(vr.value) == Relation
::Equal))
191    (ldesc);
192  }
193}
194 
195// Takes an integer and distributes its bits across a floating
196// point value.  The LSB is used to complement the result.
197std::uint32_t MakeReal(std::uint32_t n) {
198  int shifts[] = {-1, 31, 23, 30, 22, 0, 24, 29, 25, 28, 26, 1, 16, 21, 2, -1};
199  std::uint32_t x{0};
200  for (int j{1}; shifts[j] >= 0; ++j) {
201    x |= ((n >> j) & 1) << shifts[j];
202  }
203  x ^= -(n & 1);
204  return x;
205}
206 
207std::uint64_t MakeReal(std::uint64_t n) {
208  int shifts[] = {
209      -1, 63, 52, 62, 51, 0, 53, 61, 54, 60, 55, 59, 1, 16, 50, 2, -1};
210  std::uint64_t x{0};
211  for (int j{1}; shifts[j] >= 0; ++j) {
212    x |= ((n >> j) & 1) << shifts[j];
213  }
214  x ^= -(n & 1);
215  return x;
216}
217 
218inline bool IsNaN(std::uint32_t x) {
219  return (x & 0x7f800000) == 0x7f800000 && (x & 0x007fffff) != 0;
220}
221 
222inline bool IsNaN(std::uint64_t x) {
223  return (x & 0x7ff0000000000000) == 0x7ff0000000000000 &&
224      (x & 0x000fffffffffffff) != 0;
225}
226 
227inline bool IsInfinite(std::uint32_t x) {
228  return (x & 0x7fffffff) == 0x7f800000;
229}
230 
231inline bool IsInfinite(std::uint64_t x) {
232  return (x & 0x7fffffffffffffff) == 0x7ff0000000000000;
233}
234 
235inline bool IsNegative(std::uint32_t x) { return (x & 0x80000000) != 0; }
236 
237inline bool IsNegative(std::uint64_t x) {
238  return (x & 0x8000000000000000) != 0;
239}
240 
241inline std::uint32_t NormalizeNaN(std::uint32_t x) {
242  if (IsNaN(x)) {
243    x = 0x7fe00000;
244  }
245  return x;
246}
247 
248inline std::uint64_t NormalizeNaN(std::uint64_t x) {
249  if (IsNaN(x)) {
250    x = 0x7ffc000000000000;
251  }
252  return x;
253}
254 
255enum FlagBits {
256  Overflow = 1,
257  DivideByZero = 2,
258  InvalidArgument = 4,
259  Underflow = 8,
260  Inexact = 16,
261};
262 
263#ifdef __clang__1
264// clang support for fenv.h is broken, so tests of flag settings
265// are disabled.
266inline std::uint32_t FlagsToBits(const RealFlags &) { return 0; }
267#else
268inline std::uint32_t FlagsToBits(const RealFlags &flags) {
269  std::uint32_t bits{0};
270  if (flags.test(RealFlag::Overflow)) {
271    bits |= Overflow;
272  }
273  if (flags.test(RealFlag::DivideByZero)) {
274    bits |= DivideByZero;
275  }
276  if (flags.test(RealFlag::InvalidArgument)) {
277    bits |= InvalidArgument;
278  }
279  if (flags.test(RealFlag::Underflow)) {
280    bits |= Underflow;
281  }
282  if (flags.test(RealFlag::Inexact)) {
283    bits |= Inexact;
284  }
285  return bits;
286}
287#endif // __clang__
288 
289template <typename UINT = std::uint32_t, typename FLT = float, typename REAL>
290void inttest(std::int64_t x, int pass, Rounding rounding) {
291  union {
292    UINT ui;
293    FLT f;
294  } u;
295  ScopedHostFloatingPointEnvironment fpenv;
296  Integer8 ix{x};
297  ValueWithRealFlags<REAL> real;
298  real = real.value.FromInteger(ix, rounding);
299#ifndef __clang__1 // broken and also slow
300  fpenv.ClearFlags();
301#endif
302  FLT fcheck = x; // TODO unsigned too
303  auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
304  u.f = fcheck;
305  UINT rcheck{NormalizeNaN(u.ui)};
306  UINT check = real.value.RawBits().ToUInt64();
307  MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 307, (rcheck
), "check", (check))("%d 0x%llx", pass, x);
308  MATCH(actualFlags, FlagsToBits(real.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 308, (actualFlags
), "FlagsToBits(real.flags)", (FlagsToBits(real.flags)))("%d 0x%llx", pass, x);
309}
310 
311template <typename FLT = float> FLT ToIntPower(FLT x, int power) {
312  if (power == 0) {
313    return x / x;
314  }
315  bool negative{power < 0};
316  if (negative) {
317    power = -power;
318  }
319  FLT result{1};
320  while (power > 0) {
321    if (power & 1) {
322      result *= x;
323    }
324    x *= x;
325    power >>= 1;
326  }
327  if (negative) {
328    result = 1.0 / result;
329  }
330  return result;
331}
332 
333template <typename FLT, int decimalDigits>
334FLT TimesIntPowerOfTen(FLT x, int power) {
335  if (power > decimalDigits || power < -decimalDigits) {
336    auto maxExactPowerOfTen{
337        TimesIntPowerOfTen<FLT, decimalDigits>(1, decimalDigits)};
338    auto big{ToIntPower<FLT>(maxExactPowerOfTen, power / decimalDigits)};
339    auto small{
340        TimesIntPowerOfTen<FLT, decimalDigits>(1, power % decimalDigits)};
341    return (x * big) * small;
342  }
343  return x * ToIntPower<FLT>(10.0, power);
344}
345 
346template <typename UINT = std::uint32_t, typename FLT = float,
347    typename REAL = Real4>
348void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
349  for (int j{0}; j < 63; ++j) {
350    std::int64_t x{1};
351    x <<= j;
352    inttest<UINT, FLT, REAL>(x, pass, rounding);
353    inttest<UINT, FLT, REAL>(-x, pass, rounding);
354  }
355  inttest<UINT, FLT, REAL>(0, pass, rounding);
356  inttest<UINT, FLT, REAL>(
357      static_cast<std::int64_t>(0x8000000000000000), pass, rounding);
358 
359  union {
360    UINT ui;
361    FLT f;
362  } u;
363  ScopedHostFloatingPointEnvironment fpenv;
364 
365  for (UINT j{0}; j < opds; ++j) {
366 
367    UINT rj{MakeReal(j)};
368    u.ui = rj;
369    FLT fj{u.f};
370    REAL x{typename REAL::Word{std::uint64_t{rj}}};
371 
372    // unary operations
373    {
374      ValueWithRealFlags<REAL> aint{x.ToWholeNumber()};
375#ifndef __clang__1 // broken and also slow
376      fpenv.ClearFlags();
377#endif
378      FLT fcheck{std::trunc(fj)};
379      auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
380      actualFlags &= ~Inexact; // x86 std::trunc can set Inexact; AINT ain't
381      u.f = fcheck;
382#ifndef __clang__1
383      if (IsNaN(u.ui)) {
384        actualFlags |= InvalidArgument; // x86 std::trunc(NaN) workaround
385      }
386#endif
387      UINT rcheck{NormalizeNaN(u.ui)};
388      UINT check = aint.value.RawBits().ToUInt64();
389      MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 389, (rcheck
), "check", (check))
390      ("%d AINT(0x%jx)", pass, static_cast<std::intmax_t>(rj));
391      MATCH(actualFlags, FlagsToBits(aint.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 391, (actualFlags
), "FlagsToBits(aint.flags)", (FlagsToBits(aint.flags)))
392      ("%d AINT(0x%jx)", pass, static_cast<std::intmax_t>(rj));
393    }
394 
395    {
396      ValueWithRealFlags<REAL> root{x.SQRT(rounding)};
397#ifndef __clang__1 // broken and also slow
398      fpenv.ClearFlags();
399#endif
400      FLT fcheck{std::sqrt(fj)};
401      auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
402      u.f = fcheck;
403      UINT rcheck{NormalizeNaN(u.ui)};
404      UINT check = root.value.RawBits().ToUInt64();
405      MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 405, (rcheck
), "check", (check))
406      ("%d SQRT(0x%jx)", pass, static_cast<std::intmax_t>(rj));
407      MATCH(actualFlags, FlagsToBits(root.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 407, (actualFlags
), "FlagsToBits(root.flags)", (FlagsToBits(root.flags)))
408      ("%d SQRT(0x%jx)", pass, static_cast<std::intmax_t>(rj));
409    }
410 
411    {
412      MATCH(IsNaN(rj), x.IsNotANumber())testing::Match("flang/unittests/Evaluate/real.cpp", 412, (IsNaN
(rj)), "x.IsNotANumber()", (x.IsNotANumber()))
413      ("%d IsNaN(0x%jx)", pass, static_cast<std::intmax_t>(rj));
414      MATCH(IsInfinite(rj), x.IsInfinite())testing::Match("flang/unittests/Evaluate/real.cpp", 414, (IsInfinite
(rj)), "x.IsInfinite()", (x.IsInfinite()))
415      ("%d IsInfinite(0x%jx)", pass, static_cast<std::intmax_t>(rj));
416 
417      static constexpr int kind{REAL::bits / 8};
418      std::string ssBuf, cssBuf;
419      llvm::raw_string_ostream ss{ssBuf};
420      llvm::raw_string_ostream css{cssBuf};
421      x.AsFortran(ss, kind, false /*exact*/);
422      std::string s{ss.str()};
423      if (IsNaN(rj)) {
424        css << "(0._" << kind << "/0.)";
425        MATCH(css.str(), s)testing::Match("flang/unittests/Evaluate/real.cpp", 425, (css
.str()), "s", (s))
426        ("%d invalid(0x%jx)", pass, static_cast<std::intmax_t>(rj));
427      } else if (IsInfinite(rj)) {
428        css << '(';
429        if (IsNegative(rj)) {
430          css << '-';
431        }
432        css << "1._" << kind << "/0.)";
433        MATCH(css.str(), s)testing::Match("flang/unittests/Evaluate/real.cpp", 433, (css
.str()), "s", (s))
434        ("%d overflow(0x%jx)", pass, static_cast<std::intmax_t>(rj));
435      } else {
436        const char *p = s.data();
437        if (*p == '(') {
438          ++p;
439        }
440        auto readBack{REAL::Read(p, rounding)};
441        MATCH(rj, readBack.value.RawBits().ToUInt64())testing::Match("flang/unittests/Evaluate/real.cpp", 441, (rj)
, "readBack.value.RawBits().ToUInt64()", (readBack.value.RawBits
().ToUInt64()))
442        ("%d Read(AsFortran()) 0x%jx %s %g", pass,
443            static_cast<std::intmax_t>(rj), s.data(), static_cast<double>(fj));
444        MATCH('_', *p)testing::Match("flang/unittests/Evaluate/real.cpp", 444, ('_'
), "*p", (*p))
445        ("%d Read(AsFortran()) 0x%jx %s %d", pass,
446            static_cast<std::intmax_t>(rj), s.data(),
447            static_cast<int>(p - s.data()));
448      }
449    }
450 
451    // dyadic operations
452    for (UINT k{0}; k < opds; ++k) {
453      UINT rk{MakeReal(k)};
454      u.ui = rk;
455      FLT fk{u.f};
456      REAL y{typename REAL::Word{std::uint64_t{rk}}};
457      {
458        ValueWithRealFlags<REAL> sum{x.Add(y, rounding)};
459#ifndef __clang__1 // broken and also slow
460        fpenv.ClearFlags();
461#endif
462        FLT fcheck{fj + fk};
463        auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
464        u.f = fcheck;
465        UINT rcheck{NormalizeNaN(u.ui)};
466        UINT check = sum.value.RawBits().ToUInt64();
467        MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 467, (rcheck
), "check", (check))
468        ("%d 0x%jx + 0x%jx", pass, static_cast<std::intmax_t>(rj),
469            static_cast<std::intmax_t>(rk));
470        MATCH(actualFlags, FlagsToBits(sum.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 470, (actualFlags
), "FlagsToBits(sum.flags)", (FlagsToBits(sum.flags)))
471        ("%d 0x%jx + 0x%jx", pass, static_cast<std::intmax_t>(rj),
472            static_cast<std::intmax_t>(rk));
473      }
474      {
475        ValueWithRealFlags<REAL> diff{x.Subtract(y, rounding)};
476#ifndef __clang__1 // broken and also slow
477        fpenv.ClearFlags();
478#endif
479        FLT fcheck{fj - fk};
480        auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
481        u.f = fcheck;
482        UINT rcheck{NormalizeNaN(u.ui)};
483        UINT check = diff.value.RawBits().ToUInt64();
484        MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 484, (rcheck
), "check", (check))
485        ("%d 0x%jx - 0x%jx", pass, static_cast<std::intmax_t>(rj),
486            static_cast<std::intmax_t>(rk));
487        MATCH(actualFlags, FlagsToBits(diff.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 487, (actualFlags
), "FlagsToBits(diff.flags)", (FlagsToBits(diff.flags)))
488        ("%d 0x%jx - 0x%jx", pass, static_cast<std::intmax_t>(rj),
489            static_cast<std::intmax_t>(rk));
490      }
491      {
492        ValueWithRealFlags<REAL> prod{x.Multiply(y, rounding)};
493#ifndef __clang__1 // broken and also slow
494        fpenv.ClearFlags();
495#endif
496        FLT fcheck{fj * fk};
497        auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
498        u.f = fcheck;
499        UINT rcheck{NormalizeNaN(u.ui)};
500        UINT check = prod.value.RawBits().ToUInt64();
501        MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 501, (rcheck
), "check", (check))
502        ("%d 0x%jx * 0x%jx", pass, static_cast<std::intmax_t>(rj),
503            static_cast<std::intmax_t>(rk));
504        MATCH(actualFlags, FlagsToBits(prod.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 504, (actualFlags
), "FlagsToBits(prod.flags)", (FlagsToBits(prod.flags)))
505        ("%d 0x%jx * 0x%jx", pass, static_cast<std::intmax_t>(rj),
506            static_cast<std::intmax_t>(rk));
507      }
508      {
509        ValueWithRealFlags<REAL> quot{x.Divide(y, rounding)};
510#ifndef __clang__1 // broken and also slow
511        fpenv.ClearFlags();
512#endif
513        FLT fcheck{fj / fk};
514        auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
515        u.f = fcheck;
516        UINT rcheck{NormalizeNaN(u.ui)};
517        UINT check = quot.value.RawBits().ToUInt64();
518        MATCH(rcheck, check)testing::Match("flang/unittests/Evaluate/real.cpp", 518, (rcheck
), "check", (check))
519        ("%d 0x%jx / 0x%jx", pass, static_cast<std::intmax_t>(rj),
520            static_cast<std::intmax_t>(rk));
521        MATCH(actualFlags, FlagsToBits(quot.flags))testing::Match("flang/unittests/Evaluate/real.cpp", 521, (actualFlags
), "FlagsToBits(quot.flags)", (FlagsToBits(quot.flags)))
522        ("%d 0x%jx / 0x%jx", pass, static_cast<std::intmax_t>(rj),
523            static_cast<std::intmax_t>(rk));
524      }
525    }
526  }
527}
528 
529void roundTest(int rm, Rounding rounding, std::uint32_t opds) {
530  basicTests<Real2>(rm, rounding);
531  basicTests<Real3>(rm, rounding);
532  basicTests<Real4>(rm, rounding);
533  basicTests<Real8>(rm, rounding);
534  basicTests<Real10>(rm, rounding);
535  basicTests<Real16>(rm, rounding);
536  ScopedHostFloatingPointEnvironment::SetRounding(rounding);
537  subsetTests<std::uint32_t, float, Real4>(rm, rounding, opds);
538  subsetTests<std::uint64_t, double, Real8>(rm, rounding, opds);
539}
540 
541int main() {
542  dumpTest();
543  std::uint32_t opds{512}; // for quick testing by default
544  if (const char *p{std::getenv("REAL_TEST_OPERANDS")}) {
545    // Use 8192 or 16384 for more exhaustive testing.
546    opds = std::atol(p);
547  }
548  roundTest(0, Rounding{RoundingMode::TiesToEven}, opds);
549  roundTest(1, Rounding{RoundingMode::ToZero}, opds);
550  roundTest(2, Rounding{RoundingMode::Up}, opds);
551  roundTest(3, Rounding{RoundingMode::Down}, opds);
552  // TODO: how to test Rounding::TiesAwayFromZero on x86?
553  return testing::Complete();
554}

←

/build/source/flang/include/flang/Evaluate/real.h

→

1//===-- include/flang/Evaluate/real.h ---------------------------*- 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//===----------------------------------------------------------------------===//

9#ifndef FORTRAN_EVALUATE_REAL_H_
10#define FORTRAN_EVALUATE_REAL_H_

12#include "formatting.h"
13#include "integer.h"
14#include "rounding-bits.h"
15#include "flang/Common/real.h"
16#include "flang/Evaluate/target.h"
17#include <cinttypes>
18#include <limits>
19#include <string>

21// Some environments, viz. clang on Darwin, allow the macro HUGE
22// to leak out of <math.h> even when it is never directly included.
23#undef HUGE

25namespace llvm {
26class raw_ostream;
27}
28namespace Fortran::evaluate::value {

30// LOG10(2.)*1E12
31static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};

33// Models IEEE binary floating-point numbers (IEEE 754-2008,
34// ISO/IEC/IEEE 60559.2011).  The first argument to this
35// class template must be (or look like) an instance of Integer<>;
36// the second specifies the number of effective bits (binary precision)
37// in the fraction.
38template <typename WORD, int PREC>
39class Real : public common::RealDetails<PREC> {
40public:
using Word = WORD;
static constexpr int binaryPrecision{PREC};
using Details = common::RealDetails<PREC>;
using Details::exponentBias;
using Details::exponentBits;
using Details::isImplicitMSB;
using Details::maxExponent;
using Details::significandBits;

static constexpr int bits{Word::bits};
static_assert(bits >= Details::bits);
using Fraction = Integer<binaryPrecision>; // all bits made explicit

template <typename W, int P> friend class Real;

constexpr Real() {} // +0.0
constexpr Real(const Real &) = default;
constexpr Real(Real &&) = default;
constexpr Real(const Word &bits) : word_{bits} {}
constexpr Real &operator=(const Real &) = default;
constexpr Real &operator=(Real &&) = default;

constexpr bool operator==(const Real &that) const {
  return word_ == that.word_;
}

constexpr bool IsSignBitSet() const { return word_.BTEST(bits - 1); }
constexpr bool IsNegative() const {
  return !IsNotANumber() && IsSignBitSet();
}
constexpr bool IsNotANumber() const {
  return Exponent() == maxExponent && !GetSignificand().IsZero();
}
constexpr bool IsQuietNaN() const {
  return Exponent() == maxExponent &&
      GetSignificand().BTEST(significandBits - 1);
}
constexpr bool IsSignalingNaN() const {
  return IsNotANumber() && !GetSignificand().BTEST(significandBits - 1);
}
constexpr bool IsInfinite() const {
  return Exponent() == maxExponent && GetSignificand().IsZero();
}
constexpr bool IsFinite() const { return Exponent() != maxExponent; }
constexpr bool IsZero() const {
  return Exponent() == 0 && GetSignificand().IsZero();
}
constexpr bool IsSubnormal() const {
  return Exponent() == 0 && !GetSignificand().IsZero();
}
constexpr bool IsNormal() const {
  return !(IsInfinite() || IsNotANumber() || IsSubnormal());
}

constexpr Real ABS() const { // non-arithmetic, no flags returned
  return {word_.IBCLR(bits - 1)};
}
constexpr Real SetSign(bool toNegative) const { // non-arithmetic
  if (toNegative) {
    return {word_.IBSET(bits - 1)};
  } else {
    return ABS();
  }
}
constexpr Real SIGN(const Real &x) const { return SetSign(x.IsSignBitSet()); }

constexpr Real Negate() const { return {word_.IEOR(word_.MASKL(1))}; }

Relation Compare(const Real &) const;
ValueWithRealFlags<Real> Add(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;
ValueWithRealFlags<Real> Subtract(const Real &y,
    Rounding rounding = TargetCharacteristics::defaultRounding) const {
  return Add(y.Negate(), rounding);
}
ValueWithRealFlags<Real> Multiply(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;
ValueWithRealFlags<Real> Divide(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;

ValueWithRealFlags<Real> SQRT(
    Rounding rounding = TargetCharacteristics::defaultRounding) const;
// NEAREST(), IEEE_NEXT_AFTER(), IEEE_NEXT_UP(), and IEEE_NEXT_DOWN()
ValueWithRealFlags<Real> NEAREST(bool upward) const;
// HYPOT(x,y)=SQRT(x**2 + y**2) computed so as to avoid spurious
// intermediate overflows.
ValueWithRealFlags<Real> HYPOT(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;
// DIM(X,Y) = MAX(X-Y, 0)
ValueWithRealFlags<Real> DIM(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;
// MOD(x,y) = x - AINT(x/y)*y
// MODULO(x,y) = x - FLOOR(x/y)*y
ValueWithRealFlags<Real> MOD(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;
ValueWithRealFlags<Real> MODULO(const Real &,
    Rounding rounding = TargetCharacteristics::defaultRounding) const;

template <typename INT> constexpr INT EXPONENT() const {
  if (Exponent() == maxExponent) {
    return INT::HUGE();
  } else if (IsZero()) {
    return {0};
  } else {
    return {UnbiasedExponent() + 1};
  }
}

static constexpr Real EPSILON() {
  Real epsilon;
  epsilon.Normalize(
      false, exponentBias + 1 - binaryPrecision, Fraction::MASKL(1));
  return epsilon;
}
static constexpr Real HUGE() {
  Real huge;
  huge.Normalize(false, maxExponent - 1, Fraction::MASKR(binaryPrecision));
  return huge;
}
static constexpr Real TINY() {
  Real tiny;
  tiny.Normalize(false, 1, Fraction::MASKL(1)); // minimum *normal* number
  return tiny;
}

static constexpr int DIGITS{binaryPrecision};
static constexpr int PRECISION{Details::decimalPrecision};
static constexpr int RANGE{Details::decimalRange};
static constexpr int MAXEXPONENT{maxExponent - exponentBias};
static constexpr int MINEXPONENT{2 - exponentBias};
Real RRSPACING() const;
Real SPACING() const;
Real SET_EXPONENT(std::int64_t) const;
Real FRACTION() const;

// SCALE(); also known as IEEE_SCALB and (in IEEE-754 '08) ScaleB.
template <typename INT>
ValueWithRealFlags<Real> SCALE(const INT &by,
    Rounding rounding = TargetCharacteristics::defaultRounding) const {
  // Normalize a fraction with just its LSB set and then multiply.
  // (Set the LSB, not the MSB, in case the scale factor needs to
  //  be subnormal.)
  auto adjust{exponentBias + binaryPrecision - 1};
  auto expo{adjust + by.ToInt64()};
  Real twoPow;
  RealFlags flags;
  int rMask{1};
  if (IsZero()) {
    expo = exponentBias; // ignore by, don't overflow
  } else if (by > INT{maxExponent}) {
    expo = maxExponent + binaryPrecision - 1;
  } else if (by < INT{-adjust}) { // underflow
    expo = 0;
    rMask = 0;
    flags.set(RealFlag::Underflow);
  }
  flags |=
      twoPow.Normalize(false, static_cast<int>(expo), Fraction::MASKR(rMask));
  ValueWithRealFlags<Real> result{Multiply(twoPow, rounding)};
  result.flags |= flags;
  return result;
}

constexpr Real FlushSubnormalToZero() const {
  if (IsSubnormal()) {
    return Real{};
  }
  return *this;
}

// TODO: Configurable NotANumber representations
static constexpr Real NotANumber() {
  return {Word{maxExponent}
              .SHIFTL(significandBits)
              .IBSET(significandBits - 1)
              .IBSET(significandBits - 2)};
}

static constexpr Real PositiveZero() { return Real{}; }

static constexpr Real NegativeZero() { return {Word{}.MASKL(1)}; }

static constexpr Real Infinity(bool negative) {
  Word infinity{maxExponent};
  infinity = infinity.SHIFTL(significandBits);
  if (negative) {
    infinity = infinity.IBSET(infinity.bits - 1);
  }
  return {infinity};
}

template <typename INT>
static ValueWithRealFlags<Real> FromInteger(const INT &n,
    Rounding rounding = TargetCharacteristics::defaultRounding) {
  bool isNegative{n.IsNegative()};
  INT absN{n};
  if (isNegative) {
    absN = n.Negate().value; // overflow is safe to ignore
  }
  int leadz{absN.LEADZ()};
  if (leadz >= absN.bits) {
    return {}; // all bits zero -> +0.0
  }
  ValueWithRealFlags<Real> result;
  int exponent{exponentBias + absN.bits - leadz - 1};
  int bitsNeeded{absN.bits - (leadz + isImplicitMSB)};
  int bitsLost{bitsNeeded - significandBits};
  if (bitsLost <= 0) {
    Fraction fraction{Fraction::ConvertUnsigned(absN).value};
    result.flags |= result.value.Normalize(
        isNegative, exponent, fraction.SHIFTL(-bitsLost));
  } else {
    Fraction fraction{Fraction::ConvertUnsigned(absN.SHIFTR(bitsLost)).value};
    result.flags |= result.value.Normalize(isNegative, exponent, fraction);
    RoundingBits roundingBits{absN, bitsLost};
    result.flags |= result.value.Round(rounding, roundingBits);
  }
  return result;
}

// Conversion to integer in the same real format (AINT(), ANINT())
ValueWithRealFlags<Real> ToWholeNumber(
    common::RoundingMode = common::RoundingMode::ToZero) const;

// Conversion to an integer (INT(), NINT(), FLOOR(), CEILING())
template <typename INT>
constexpr ValueWithRealFlags<INT> ToInteger(
    common::RoundingMode mode = common::RoundingMode::ToZero) const {
  ValueWithRealFlags<INT> result;
25
←
'result' initialized here→
  if (IsNotANumber()) {
26
←
Taking false branch→
    result.flags.set(RealFlag::InvalidArgument);
    result.value = result.value.HUGE();
    return result;
  }
  ValueWithRealFlags<Real> intPart{ToWholeNumber(mode)};
  result.flags |= intPart.flags;
  int exponent{intPart.value.Exponent()};
  // shift positive -> left shift, negative -> right shift
  int shift{exponent - exponentBias - binaryPrecision + 1};
  // Apply any right shift before moving to the result type
  auto rshifted{intPart.value.GetFraction().SHIFTR(-shift)};
  auto converted{result.value.ConvertUnsigned(rshifted)};
  if (converted.overflow26.1
Field 'overflow' is false
1
Field 'overflow' is false
1
Field 'overflow' is false
) {
27
←
Taking false branch→
    result.flags.set(RealFlag::Overflow);
  }
  result.value = converted.value.SHIFTL(shift);
  if (converted.value.CompareUnsigned(result.value.SHIFTR(shift)) !=
28
←
Taking true branch→
      Ordering::Equal) {
    result.flags.set(RealFlag::Overflow);
  }
  if (IsSignBitSet()) {
29
←
Taking true branch→
    result.value = result.value.Negate().value;
30
←
Assigning value→
  }
  if (!result.value.IsZero()) {
31
←
Taking true branch→
    if (IsSignBitSet() != result.value.IsNegative()) {
32
←
Taking false branch→
      result.flags.set(RealFlag::Overflow);
    }
  }
  if (result.flags.test(RealFlag::Overflow)) {
33
←
Taking false branch→
    result.value =
        IsSignBitSet() ? result.value.MASKL(1) : result.value.HUGE();
  }
  return result;
34
←
Assigning value→
}

template <typename A>
static ValueWithRealFlags<Real> Convert(
    const A &x, Rounding rounding = TargetCharacteristics::defaultRounding) {
  ValueWithRealFlags<Real> result;
  if (x.IsNotANumber()) {
    result.flags.set(RealFlag::InvalidArgument);
    result.value = NotANumber();
    return result;
  }
  bool isNegative{x.IsNegative()};
  A absX{x};
  if (isNegative) {
    absX = x.Negate();
  }
  int exponent{exponentBias + x.UnbiasedExponent()};
  int bitsLost{A::binaryPrecision - binaryPrecision};
  if (exponent < 1) {
    bitsLost += 1 - exponent;
    exponent = 1;
  }
  typename A::Fraction xFraction{x.GetFraction()};
  if (bitsLost <= 0) {
    Fraction fraction{
        Fraction::ConvertUnsigned(xFraction).value.SHIFTL(-bitsLost)};
    result.flags |= result.value.Normalize(isNegative, exponent, fraction);
  } else {
    Fraction fraction{
        Fraction::ConvertUnsigned(xFraction.SHIFTR(bitsLost)).value};
    result.flags |= result.value.Normalize(isNegative, exponent, fraction);
    RoundingBits roundingBits{xFraction, bitsLost};
    result.flags |= result.value.Round(rounding, roundingBits);
  }
  return result;
}

constexpr Word RawBits() const { return word_; }

// Extracts "raw" biased exponent field.
constexpr int Exponent() const {
  return word_.IBITS(significandBits, exponentBits).ToUInt64();
}

// Extracts the fraction; any implied bit is made explicit.
constexpr Fraction GetFraction() const {
  Fraction result{Fraction::ConvertUnsigned(word_).value};
  if constexpr (!isImplicitMSB) {
    return result;
  } else {
    int exponent{Exponent()};
    if (exponent > 0 && exponent < maxExponent) {
      return result.IBSET(significandBits);
    } else {
      return result.IBCLR(significandBits);
    }
  }
}

// Extracts unbiased exponent value.
// Corrects the exponent value of a subnormal number.
// Note that the result is one less than the EXPONENT intrinsic;
// UnbiasedExponent(1.0) is 0, not 1.
constexpr int UnbiasedExponent() const {
  int exponent{Exponent() - exponentBias};
  if (IsSubnormal()) {
    ++exponent;
  }
  return exponent;
}

static ValueWithRealFlags<Real> Read(const char *&,
    Rounding rounding = TargetCharacteristics::defaultRounding);
std::string DumpHexadecimal() const;

// Emits a character representation for an equivalent Fortran constant
// or parenthesized constant expression that produces this value.
llvm::raw_ostream &AsFortran(
    llvm::raw_ostream &, int kind, bool minimal = false) const;

384private:
using Significand = Integer<significandBits>; // no implicit bit

constexpr Significand GetSignificand() const {
  return Significand::ConvertUnsigned(word_).value;
}

constexpr int CombineExponents(const Real &y, bool forDivide) const {
  int exponent = Exponent(), yExponent = y.Exponent();
  // A zero exponent field value has the same weight as 1.
  exponent += !exponent;
  yExponent += !yExponent;
  if (forDivide) {
    exponent += exponentBias - yExponent;
  } else {
    exponent += yExponent - exponentBias + 1;
  }
  return exponent;
}

static constexpr bool NextQuotientBit(
    Fraction &top, bool &msb, const Fraction &divisor) {
  bool greaterOrEqual{msb || top.CompareUnsigned(divisor) != Ordering::Less};
  if (greaterOrEqual) {
    top = top.SubtractSigned(divisor).value;
  }
  auto doubled{top.AddUnsigned(top)};
  top = doubled.value;
  msb = doubled.carry;
  return greaterOrEqual;
}

// Normalizes and marshals the fields of a floating-point number in place.
// The value is a number, and a zero fraction means a zero value (i.e.,
// a maximal exponent and zero fraction doesn't signify infinity, although
// this member function will detect overflow and encode infinities).
RealFlags Normalize(bool negative, int exponent, const Fraction &fraction,
    Rounding rounding = TargetCharacteristics::defaultRounding,
    RoundingBits *roundingBits = nullptr);

// Rounds a result, if necessary, in place.
RealFlags Round(Rounding, const RoundingBits &, bool multiply = false);

static void NormalizeAndRound(ValueWithRealFlags<Real> &result,
    bool isNegative, int exponent, const Fraction &, Rounding, RoundingBits,
    bool multiply = false);

Word word_{}; // an Integer<>
432};

434extern template class Real<Integer<16>, 11>; // IEEE half format
435extern template class Real<Integer<16>, 8>; // the "other" half format
436extern template class Real<Integer<32>, 24>; // IEEE single
437extern template class Real<Integer<64>, 53>; // IEEE double
438extern template class Real<Integer<80>, 64>; // 80387 extended precision
439extern template class Real<Integer<128>, 113>; // IEEE quad
440// N.B. No "double-double" support.
441} // namespace Fortran::evaluate::value
442#endif // FORTRAN_EVALUATE_REAL_H_

←

/build/source/flang/include/flang/Evaluate/integer.h

1//===-- include/flang/Evaluate/integer.h ------------------------*- 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//===----------------------------------------------------------------------===//

9#ifndef FORTRAN_EVALUATE_INTEGER_H_
10#define FORTRAN_EVALUATE_INTEGER_H_

12// Emulates binary integers of an arbitrary (but fixed) bit size for use
13// when the host C++ environment does not support that size or when the
14// full suite of Fortran's integer intrinsic scalar functions are needed.
15// The data model is typeless, so signed* and unsigned operations
16// are distinguished from each other with distinct member function interfaces.
17// (*"Signed" here means two's-complement, just to be clear.  Ones'-complement
18// and signed-magnitude encodings appear to be extinct in 2018.)

20#include "flang/Common/bit-population-count.h"
21#include "flang/Common/leading-zero-bit-count.h"
22#include "flang/Evaluate/common.h"
23#include <cinttypes>
24#include <climits>
25#include <cstddef>
26#include <cstdint>
27#include <string>
28#include <type_traits>

30// Some environments, viz. clang on Darwin, allow the macro HUGE
31// to leak out of <math.h> even when it is never directly included.
32#undef HUGE

34namespace Fortran::evaluate::value {

36// Implements an integer as an assembly of smaller host integer parts
37// that constitute the digits of a large-radix fixed-point number.
38// For best performance, the type of these parts should be half of the
39// size of the largest efficient integer supported by the host processor.
40// These parts are stored in either little- or big-endian order, which can
41// match that of the host's endianness or not; but if the ordering matches
42// that of the host, raw host data can be overlaid with a properly configured
43// instance of this class and used in situ.
44// To facilitate exhaustive testing of what would otherwise be more rare
45// edge cases, this class template may be configured to use other part
46// types &/or partial fields in the parts.  The radix (i.e., the number
47// of possible values in a part), however, must be a power of two; this
48// template class is not generalized to enable, say, decimal arithmetic.
49// Member functions that correspond to Fortran intrinsic functions are
50// named accordingly in ALL CAPS so that they can be referenced easily in
51// the language standard.
52template <int BITS, bool IS_LITTLE_ENDIAN = isHostLittleEndian,
  int PARTBITS = BITS <= 32 ? BITS : 32,
  typename PART = HostUnsignedInt<PARTBITS>,
  typename BIGPART = HostUnsignedInt<PARTBITS * 2>>
56class Integer {
57public:
static constexpr int bits{BITS};
static constexpr int partBits{PARTBITS};
using Part = PART;
using BigPart = BIGPART;
static_assert(std::is_integral_v<Part>);
static_assert(std::is_unsigned_v<Part>);
static_assert(std::is_integral_v<BigPart>);
static_assert(std::is_unsigned_v<BigPart>);
static_assert(CHAR_BIT8 * sizeof(BigPart) >= 2 * partBits);
static constexpr bool littleEndian{IS_LITTLE_ENDIAN};

69private:
static constexpr int maxPartBits{CHAR_BIT8 * sizeof(Part)};
static_assert(partBits > 0 && partBits <= maxPartBits);
static constexpr int extraPartBits{maxPartBits - partBits};
static constexpr int parts{(bits + partBits - 1) / partBits};
static_assert(parts >= 1);
static constexpr int extraTopPartBits{
    extraPartBits + (parts * partBits) - bits};
static constexpr int topPartBits{maxPartBits - extraTopPartBits};
static_assert(topPartBits > 0 && topPartBits <= partBits);
static_assert((parts - 1) * partBits + topPartBits == bits);
static constexpr Part partMask{static_cast<Part>(~0) >> extraPartBits};
static constexpr Part topPartMask{static_cast<Part>(~0) >> extraTopPartBits};

83public:
// Some types used for member function results
struct ValueWithOverflow {
  Integer value;
  bool overflow;
};

struct ValueWithCarry {
  Integer value;
  bool carry;
};

struct Product {
  bool SignedMultiplicationOverflowed() const {
    return lower.IsNegative() ? (upper.POPCNT() != bits) : !upper.IsZero();
  }
  Integer upper, lower;
};

struct QuotientWithRemainder {
  Integer quotient, remainder;
  bool divisionByZero, overflow;
};

struct PowerWithErrors {
  Integer power;
  bool divisionByZero{false}, overflow{false}, zeroToZero{false};
};

// Constructors and value-generating static functions
constexpr Integer() { Clear(); } // default constructor: zero
constexpr Integer(const Integer &) = default;
constexpr Integer(Integer &&) = default;

// C++'s integral types can all be converted to Integer
// with silent truncation.
template <typename INT, typename = std::enable_if_t<std::is_integral_v<INT>>>
constexpr Integer(INT n) {
  constexpr int nBits = CHAR_BIT8 * sizeof n;
  if constexpr (nBits < partBits) {
    if constexpr (std::is_unsigned_v<INT>) {
      // Zero-extend an unsigned smaller value.
      SetLEPart(0, n);
      for (int j{1}; j < parts; ++j) {
        SetLEPart(j, 0);
      }
    } else {
      // n has a signed type smaller than the usable
      // bits in a Part.
      // Avoid conversions that change both size and sign.
      using SignedPart = std::make_signed_t<Part>;
      Part p = static_cast<SignedPart>(n);
      SetLEPart(0, p);
      if constexpr (parts > 1) {
        Part signExtension = static_cast<SignedPart>(-(n < 0));
        for (int j{1}; j < parts; ++j) {
          SetLEPart(j, signExtension);
        }
      }
    }
  } else {
    // n has some integral type no smaller than the usable
    // bits in a Part.
    // Ensure that all shifts are smaller than a whole word.
    if constexpr (std::is_unsigned_v<INT>) {
      for (int j{0}; j < parts; ++j) {
        SetLEPart(j, static_cast<Part>(n));
        if constexpr (nBits > partBits) {
          n >>= partBits;
        } else {
          n = 0;
        }
      }
    } else {
      INT signExtension{-(n < 0)};
      static_assert(nBits >= partBits);
      if constexpr (nBits > partBits) {
        signExtension <<= nBits - partBits;
        for (int j{0}; j < parts; ++j) {
          SetLEPart(j, static_cast<Part>(n));
          n >>= partBits;
          n |= signExtension;
        }
      } else {
        SetLEPart(0, static_cast<Part>(n));
        for (int j{1}; j < parts; ++j) {
          SetLEPart(j, static_cast<Part>(signExtension));
        }
      }
    }
  }
}

constexpr Integer &operator=(const Integer &) = default;

constexpr bool operator<(const Integer &that) const {
  return CompareSigned(that) == Ordering::Less;
}
constexpr bool operator<=(const Integer &that) const {
  return CompareSigned(that) != Ordering::Greater;
}
constexpr bool operator==(const Integer &that) const {
  return CompareSigned(that) == Ordering::Equal;
}
constexpr bool operator!=(const Integer &that) const {
  return !(*this == that);
}
constexpr bool operator>=(const Integer &that) const {
  return CompareSigned(that) != Ordering::Less;
}
constexpr bool operator>(const Integer &that) const {
  return CompareSigned(that) == Ordering::Greater;
}

// Left-justified mask (e.g., MASKL(1) has only its sign bit set)
static constexpr Integer MASKL(int places) {
  if (places <= 0) {
    return {};
  } else if (places >= bits) {
    return MASKR(bits);
  } else {
    return MASKR(bits - places).NOT();
  }
}

// Right-justified mask (e.g., MASKR(1) == 1, MASKR(2) == 3, &c.)
static constexpr Integer MASKR(int places) {
  Integer result{nullptr};
  int j{0};
  for (; j + 1 < parts && places >= partBits; ++j, places -= partBits) {
    result.LEPart(j) = partMask;
  }
  if (places > 0) {
    if (j + 1 < parts) {
      result.LEPart(j++) = partMask >> (partBits - places);
    } else if (j + 1 == parts) {
      if (places >= topPartBits) {
        result.LEPart(j++) = topPartMask;
      } else {
        result.LEPart(j++) = topPartMask >> (topPartBits - places);
      }
    }
  }
  for (; j < parts; ++j) {
    result.LEPart(j) = 0;
  }
  return result;
}

static constexpr ValueWithOverflow Read(
    const char *&pp, std::uint64_t base = 10, bool isSigned = false) {
  Integer result;
  bool overflow{false};
  const char *p{pp};
  while (*p == ' ' || *p == '\t') {
    ++p;
  }
  bool negate{*p == '-'};
  if (negate || *p == '+') {
    while (*++p == ' ' || *p == '\t') {
    }
  }
  Integer radix{base};
  // This code makes assumptions about local contiguity in regions of the
  // character set and only works up to base 36.  These assumptions hold
  // for all current combinations of surviving character sets (ASCII, UTF-8,
  // EBCDIC) and the bases used in Fortran source and formatted I/O
  // (viz., 2, 8, 10, & 16).  But: management thought that a disclaimer
  // might be needed here to warn future users of this code about these
  // assumptions, so here you go, future programmer in some postapocalyptic
  // hellscape, and best of luck with the inexorable killer robots.
  for (; std::uint64_t digit = *p; ++p) {
    if (digit >= '0' && digit <= '9' && digit < '0' + base) {
      digit -= '0';
    } else if (base > 10 && digit >= 'A' && digit < 'A' + base - 10) {
      digit -= 'A' - 10;
    } else if (base > 10 && digit >= 'a' && digit < 'a' + base - 10) {
      digit -= 'a' - 10;
    } else {
      break;
    }
    Product shifted{result.MultiplyUnsigned(radix)};
    overflow |= !shifted.upper.IsZero();
    ValueWithCarry next{shifted.lower.AddUnsigned(Integer{digit})};
    overflow |= next.carry;
    result = next.value;
  }
  pp = p;
  if (negate) {
    result = result.Negate().value;
    overflow |= isSigned && !result.IsNegative() && !result.IsZero();
  } else {
    overflow |= isSigned && result.IsNegative();
  }
  return {result, overflow};
}

template <typename FROM>
static constexpr ValueWithOverflow ConvertUnsigned(const FROM &that) {
  std::uint64_t field{that.ToUInt64()};
  ValueWithOverflow result{field, false};
  if constexpr (bits < 64) {
    result.overflow = (field >> bits) != 0;
  }
  for (int j{64}; j < that.bits && !result.overflow; j += 64) {
    field = that.SHIFTR(j).ToUInt64();
    if (bits <= j) {
      result.overflow = field != 0;
    } else {
      result.value = result.value.IOR(Integer{field}.SHIFTL(j));
      if (bits < j + 64) {
        result.overflow = (field >> (bits - j)) != 0;
      }
    }
  }
  return result;
}

template <typename FROM>
static constexpr ValueWithOverflow ConvertSigned(const FROM &that) {
  ValueWithOverflow result{ConvertUnsigned(that)};
  if constexpr (bits > FROM::bits) {
    if (that.IsNegative()) {
      result.value = result.value.IOR(MASKL(bits - FROM::bits));
    }
    result.overflow = false;
  } else if constexpr (bits < FROM::bits) {
    auto back{FROM::template ConvertSigned(result.value)};
    result.overflow = back.value.CompareUnsigned(that) != Ordering::Equal;
  }
  return result;
}

std::string UnsignedDecimal() const {
  if constexpr (bits < 4) {
    char digit = '0' + ToUInt64();
    return {digit};
  } else if (IsZero()) {
    return {'0'};
  } else {
    QuotientWithRemainder qr{DivideUnsigned(10)};
    char digit = '0' + qr.remainder.ToUInt64();
    if (qr.quotient.IsZero()) {
      return {digit};
    } else {
      return qr.quotient.UnsignedDecimal() + digit;
    }
  }
}

std::string SignedDecimal() const {
  if (IsNegative()) {
    return std::string{'-'} + Negate().value.UnsignedDecimal();
  } else {
    return UnsignedDecimal();
  }
}

// Omits a leading "0x".
std::string Hexadecimal() const {
  std::string result;
  int digits{(bits + 3) >> 2};
  for (int j{0}; j < digits; ++j) {
    int pos{(digits - 1 - j) * 4};
    char nybble = IBITS(pos, 4).ToUInt64();
    if (nybble != 0 || !result.empty() || j + 1 == digits) {
      char digit = '0' + nybble;
      if (digit > '9') {
        digit += 'a' - ('9' + 1);
      }
      result += digit;
    }
  }
  return result;
}

static constexpr int DIGITS{bits - 1}; // don't count the sign bit
static constexpr Integer HUGE() { return MASKR(bits - 1); }
static constexpr Integer Least() { return MASKL(1); }
static constexpr int RANGE{// in the sense of SELECTED_INT_KIND
    // This magic value is LOG10(2.)*1E12.
    static_cast<int>(((bits - 1) * 301029995664) / 1000000000000)};

constexpr bool IsZero() const {
  for (int j{0}; j < parts; ++j) {
    if (part_[j] != 0) {
      return false;
    }
  }
  return true;
}

constexpr bool IsNegative() const {
  return (LEPart(parts - 1) >> (topPartBits - 1)) & 1;
}

constexpr Ordering CompareToZeroSigned() const {
  if (IsNegative()) {
    return Ordering::Less;
  } else if (IsZero()) {
    return Ordering::Equal;
  } else {
    return Ordering::Greater;
  }
}

// Count the number of contiguous most-significant bit positions
// that are clear.
constexpr int LEADZ() const {
  if (LEPart(parts - 1) != 0) {
    int lzbc{common::LeadingZeroBitCount(LEPart(parts - 1))};
    return lzbc - extraTopPartBits;
  }
  int upperZeroes{topPartBits};
  for (int j{1}; j < parts; ++j) {
    if (Part p{LEPart(parts - 1 - j)}) {
      int lzbc{common::LeadingZeroBitCount(p)};
      return upperZeroes + lzbc - extraPartBits;
    }
    upperZeroes += partBits;
  }
  return bits;
}

// Count the number of bit positions that are set.
constexpr int POPCNT() const {
  int count{0};
  for (int j{0}; j < parts; ++j) {
    count += common::BitPopulationCount(part_[j]);
  }
  return count;
}

// True when POPCNT is odd.
constexpr bool POPPAR() const { return POPCNT() & 1; }

constexpr int TRAILZ() const {
  auto minus1{AddUnsigned(MASKR(bits))}; // { x-1, carry = x > 0 }
  if (!minus1.carry) {
    return bits; // was zero
  } else {
    // x ^ (x-1) has all bits set at and below original least-order set bit.
    return IEOR(minus1.value).POPCNT() - 1;
  }
}

constexpr bool BTEST(int pos) const {
  if (pos < 0 || pos >= bits) {
    return false;
  } else {
    return (LEPart(pos / partBits) >> (pos % partBits)) & 1;
  }
}

constexpr Ordering CompareUnsigned(const Integer &y) const {
  for (int j{parts}; j-- > 0;) {
    if (LEPart(j) > y.LEPart(j)) {
      return Ordering::Greater;
    }
    if (LEPart(j) < y.LEPart(j)) {
      return Ordering::Less;
    }
  }
  return Ordering::Equal;
}

constexpr bool BGE(const Integer &y) const {
  return CompareUnsigned(y) != Ordering::Less;
}
constexpr bool BGT(const Integer &y) const {
  return CompareUnsigned(y) == Ordering::Greater;
}
constexpr bool BLE(const Integer &y) const { return !BGT(y); }
constexpr bool BLT(const Integer &y) const { return !BGE(y); }

constexpr Ordering CompareSigned(const Integer &y) const {
  bool isNegative{IsNegative()};
  if (isNegative != y.IsNegative()) {
    return isNegative ? Ordering::Less : Ordering::Greater;
  }
  return CompareUnsigned(y);
}

template <typename UINT = std::uint64_t> constexpr UINT ToUInt() const {
  UINT n{LEPart(0)};
  std::size_t filled{partBits};
  constexpr std::size_t maxBits{CHAR_BIT8 * sizeof n};
  for (int j{1}; filled39.1
'filled' is < 'maxBits'
1
'filled' is < 'maxBits'
1
'filled' is < 'maxBits'
 < maxBits && j < parts; ++j, filled += partBits) {
39
←
'j' initialized to 1→
40
←
Loop condition is true.  Entering loop body→
    n |= UINT{LEPart(j)} << filled;
41
←
Passing the value 1 via 1st parameter 'part'→
42
←
Calling 'Integer::LEPart'→
45
←
Returning from 'Integer::LEPart'→
46
←
The result of the left shift is undefined due to shifting '-1' by '32', which is unrepresentable in the unsigned version of the return type 'unsigned long'
  }
  return n;
}

template <typename SINT = std::int64_t, typename UINT = std::uint64_t>
constexpr SINT ToSInt() const {
  SINT n = ToUInt<UINT>();
  constexpr std::size_t maxBits{CHAR_BIT8 * sizeof n};
  if constexpr (bits < maxBits) {
    n |= -(n >> (bits - 1)) << bits;
  }
  return n;
}

constexpr std::uint64_t ToUInt64() const { return ToUInt<std::uint64_t>(); }
38
←
Calling 'Integer::ToUInt'→

constexpr std::int64_t ToInt64() const {
  return ToSInt<std::int64_t, std::uint64_t>();
}

// Ones'-complement (i.e., C's ~)
constexpr Integer NOT() const {
  Integer result{nullptr};
  for (int j{0}; j < parts; ++j) {
    result.SetLEPart(j, ~LEPart(j));
  }
  return result;
}

// Two's-complement negation (-x = ~x + 1).
// An overflow flag accompanies the result, and will be true when the
// operand is the most negative signed number (MASKL(1)).
constexpr ValueWithOverflow Negate() const {
  Integer result{nullptr};
  Part carry{1};
  for (int j{0}; j + 1 < parts; ++j) {
    Part newCarry{LEPart(j) == 0 && carry};
    result.SetLEPart(j, ~LEPart(j) + carry);
    carry = newCarry;
  }
  Part top{LEPart(parts - 1)};
  result.SetLEPart(parts - 1, ~top + carry);
  bool overflow{top != 0 && result.LEPart(parts - 1) == top};
  return {result, overflow};
}

constexpr ValueWithOverflow ABS() const {
  if (IsNegative()) {
    return Negate();
  } else {
    return {*this, false};
  }
}

// Shifts the operand left when the count is positive, right when negative.
// Vacated bit positions are filled with zeroes.
constexpr Integer ISHFT(int count) const {
  if (count < 0) {
    return SHIFTR(-count);
  } else {
    return SHIFTL(count);
  }
}

// Left shift with zero fill.
constexpr Integer SHIFTL(int count) const {
  if (count <= 0) {
    return *this;
  } else {
    Integer result{nullptr};
    int shiftParts{count / partBits};
    int bitShift{count - partBits * shiftParts};
    int j{parts - 1};
    if (bitShift == 0) {
      for (; j >= shiftParts; --j) {
        result.SetLEPart(j, LEPart(j - shiftParts));
      }
      for (; j >= 0; --j) {
        result.LEPart(j) = 0;
      }
    } else {
      for (; j > shiftParts; --j) {
        result.SetLEPart(j,
            ((LEPart(j - shiftParts) << bitShift) |
                (LEPart(j - shiftParts - 1) >> (partBits - bitShift))));
      }
      if (j == shiftParts) {
        result.SetLEPart(j, LEPart(0) << bitShift);
        --j;
      }
      for (; j >= 0; --j) {
        result.LEPart(j) = 0;
      }
    }
    return result;
  }
}

// Circular shift of a field of least-significant bits.  The least-order
// "size" bits are shifted circularly in place by "count" positions;
// the shift is leftward if count is nonnegative, rightward otherwise.
// Higher-order bits are unchanged.
constexpr Integer ISHFTC(int count, int size = bits) const {
  if (count == 0 || size <= 0) {
    return *this;
  }
  if (size > bits) {
    size = bits;
  }
  count %= size;
  if (count == 0) {
    return *this;
  }
  int middleBits{size - count}, leastBits{count};
  if (count < 0) {
    middleBits = -count;
    leastBits = size + count;
  }
  if (size == bits) {
    return SHIFTL(leastBits).IOR(SHIFTR(middleBits));
  }
  Integer unchanged{IAND(MASKL(bits - size))};
  Integer middle{IAND(MASKR(middleBits)).SHIFTL(leastBits)};
  Integer least{SHIFTR(middleBits).IAND(MASKR(leastBits))};
  return unchanged.IOR(middle).IOR(least);
}

// Double shifts, aka shifts with specific fill.
constexpr Integer SHIFTLWithFill(const Integer &fill, int count) const {
  if (count <= 0) {
    return *this;
  } else if (count >= 2 * bits) {
    return {};
  } else if (count > bits) {
    return fill.SHIFTL(count - bits);
  } else if (count == bits) {
    return fill;
  } else {
    return SHIFTL(count).IOR(fill.SHIFTR(bits - count));
  }
}

constexpr Integer SHIFTRWithFill(const Integer &fill, int count) const {
  if (count <= 0) {
    return *this;
  } else if (count >= 2 * bits) {
    return {};
  } else if (count > bits) {
    return fill.SHIFTR(count - bits);
  } else if (count == bits) {
    return fill;
  } else {
    return SHIFTR(count).IOR(fill.SHIFTL(bits - count));
  }
}

constexpr Integer DSHIFTL(const Integer &fill, int count) const {
  // DSHIFTL(I,J) shifts I:J left; the second argument is the right fill.
  return SHIFTLWithFill(fill, count);
}

constexpr Integer DSHIFTR(const Integer &value, int count) const {
  // DSHIFTR(I,J) shifts I:J right; the *first* argument is the left fill.
  return value.SHIFTRWithFill(*this, count);
}

// Vacated upper bits are filled with zeroes.
constexpr Integer SHIFTR(int count) const {
  if (count <= 0) {
    return *this;
  } else {
    Integer result{nullptr};
    int shiftParts{count / partBits};
    int bitShift{count - partBits * shiftParts};
    int j{0};
    if (bitShift == 0) {
      for (; j + shiftParts < parts; ++j) {
        result.LEPart(j) = LEPart(j + shiftParts);
      }
      for (; j < parts; ++j) {
        result.LEPart(j) = 0;
      }
    } else {
      for (; j + shiftParts + 1 < parts; ++j) {
        result.SetLEPart(j,
            (LEPart(j + shiftParts) >> bitShift) |
                (LEPart(j + shiftParts + 1) << (partBits - bitShift)));
      }
      if (j + shiftParts + 1 == parts) {
        result.LEPart(j++) = LEPart(parts - 1) >> bitShift;
      }
      for (; j < parts; ++j) {
        result.LEPart(j) = 0;
      }
    }
    return result;
  }
}

// Be advised, an arithmetic (sign-filling) right shift is not
// the same as a division by a power of two in all cases.
constexpr Integer SHIFTA(int count) const {
  if (count <= 0) {
    return *this;
  } else if (IsNegative()) {
    return SHIFTR(count).IOR(MASKL(count));
  } else {
    return SHIFTR(count);
  }
}

// Clears a single bit.
constexpr Integer IBCLR(int pos) const {
  if (pos < 0 || pos >= bits) {
    return *this;
  } else {
    Integer result{*this};
    result.LEPart(pos / partBits) &= ~(Part{1} << (pos % partBits));
    return result;
  }
}

// Sets a single bit.
constexpr Integer IBSET(int pos) const {
  if (pos < 0 || pos >= bits) {
    return *this;
  } else {
    Integer result{*this};
    result.LEPart(pos / partBits) |= Part{1} << (pos % partBits);
    return result;
  }
}

// Extracts a field.
constexpr Integer IBITS(int pos, int size) const {
  return SHIFTR(pos).IAND(MASKR(size));
}

constexpr Integer IAND(const Integer &y) const {
  Integer result{nullptr};
  for (int j{0}; j < parts; ++j) {
    result.LEPart(j) = LEPart(j) & y.LEPart(j);
  }
  return result;
}

constexpr Integer IOR(const Integer &y) const {
  Integer result{nullptr};
  for (int j{0}; j < parts; ++j) {
    result.LEPart(j) = LEPart(j) | y.LEPart(j);
  }
  return result;
}

constexpr Integer IEOR(const Integer &y) const {
  Integer result{nullptr};
  for (int j{0}; j < parts; ++j) {
    result.LEPart(j) = LEPart(j) ^ y.LEPart(j);
  }
  return result;
}

constexpr Integer MERGE_BITS(const Integer &y, const Integer &mask) const {
  return IAND(mask).IOR(y.IAND(mask.NOT()));
}

constexpr Integer MAX(const Integer &y) const {
  if (CompareSigned(y) == Ordering::Less) {
    return y;
  } else {
    return *this;
  }
}

constexpr Integer MIN(const Integer &y) const {
  if (CompareSigned(y) == Ordering::Less) {
    return *this;
  } else {
    return y;
  }
}

// Unsigned addition with carry.
constexpr ValueWithCarry AddUnsigned(
    const Integer &y, bool carryIn = false) const {
  Integer sum{nullptr};
  BigPart carry{carryIn};
  for (int j{0}; j + 1 < parts; ++j) {
    carry += LEPart(j);
    carry += y.LEPart(j);
    sum.SetLEPart(j, carry);
    carry >>= partBits;
  }
  carry += LEPart(parts - 1);
  carry += y.LEPart(parts - 1);
  sum.SetLEPart(parts - 1, carry);
  return {sum, carry > topPartMask};
}

constexpr ValueWithOverflow AddSigned(const Integer &y) const {
  bool isNegative{IsNegative()};
  bool sameSign{isNegative == y.IsNegative()};
  ValueWithCarry sum{AddUnsigned(y)};
  bool overflow{sameSign && sum.value.IsNegative() != isNegative};
  return {sum.value, overflow};
}

constexpr ValueWithOverflow SubtractSigned(const Integer &y) const {
  bool isNegative{IsNegative()};
  bool sameSign{isNegative == y.IsNegative()};
  ValueWithCarry diff{AddUnsigned(y.Negate().value)};
  bool overflow{!sameSign && diff.value.IsNegative() != isNegative};
  return {diff.value, overflow};
}

// DIM(X,Y)=MAX(X-Y, 0)
constexpr ValueWithOverflow DIM(const Integer &y) const {
  if (CompareSigned(y) != Ordering::Greater) {
    return {};
  } else {
    return SubtractSigned(y);
  }
}

constexpr ValueWithOverflow SIGN(bool toNegative) const {
  if (toNegative == IsNegative()) {
    return {*this, false};
  } else if (toNegative) {
    return Negate();
  } else {
    return ABS();
  }
}

constexpr ValueWithOverflow SIGN(const Integer &sign) const {
  return SIGN(sign.IsNegative());
}

constexpr Product MultiplyUnsigned(const Integer &y) const {
  Part product[2 * parts]{}; // little-endian full product
  for (int j{0}; j < parts; ++j) {
    if (Part xpart{LEPart(j)}) {
      for (int k{0}; k < parts; ++k) {
        if (Part ypart{y.LEPart(k)}) {
          BigPart xy{xpart};
          xy *= ypart;
818#if defined __GNUC__4 && __GNUC__4 < 8
          // && to < (2 * parts) was added to avoid GCC < 8 build failure on
          // -Werror=array-bounds. This can be removed if -Werror is disable.
          for (int to{j + k}; xy != 0 && to < (2 * parts); ++to) {
822#else
          for (int to{j + k}; xy != 0; ++to) {
824#endif
            xy += product[to];
            product[to] = xy & partMask;
            xy >>= partBits;
          }
        }
      }
    }
  }
  Integer upper{nullptr}, lower{nullptr};
  for (int j{0}; j < parts; ++j) {
    lower.LEPart(j) = product[j];
    upper.LEPart(j) = product[j + parts];
  }
  if constexpr (topPartBits < partBits) {
    upper = upper.SHIFTL(partBits - topPartBits);
    upper.LEPart(0) |= lower.LEPart(parts - 1) >> topPartBits;
    lower.LEPart(parts - 1) &= topPartMask;
  }
  return {upper, lower};
}

constexpr Product MultiplySigned(const Integer &y) const {
  bool yIsNegative{y.IsNegative()};
  Integer absy{y};
  if (yIsNegative) {
    absy = y.Negate().value;
  }
  bool isNegative{IsNegative()};
  Integer absx{*this};
  if (isNegative) {
    absx = Negate().value;
  }
  Product product{absx.MultiplyUnsigned(absy)};
  if (isNegative != yIsNegative) {
    product.lower = product.lower.NOT();
    product.upper = product.upper.NOT();
    Integer one{1};
    auto incremented{product.lower.AddUnsigned(one)};
    product.lower = incremented.value;
    if (incremented.carry) {
      product.upper = product.upper.AddUnsigned(one).value;
    }
  }
  return product;
}

constexpr QuotientWithRemainder DivideUnsigned(const Integer &divisor) const {
  if (divisor.IsZero()) {
    return {MASKR(bits), Integer{}, true, false}; // overflow to max value
  }
  int bitsDone{LEADZ()};
  Integer top{SHIFTL(bitsDone)};
  Integer quotient, remainder;
  for (; bitsDone < bits; ++bitsDone) {
    auto doubledTop{top.AddUnsigned(top)};
    top = doubledTop.value;
    remainder = remainder.AddUnsigned(remainder, doubledTop.carry).value;
    bool nextBit{remainder.CompareUnsigned(divisor) != Ordering::Less};
    quotient = quotient.AddUnsigned(quotient, nextBit).value;
    if (nextBit) {
      remainder = remainder.SubtractSigned(divisor).value;
    }
  }
  return {quotient, remainder, false, false};
}

// A nonzero remainder has the sign of the dividend, i.e., it computes
// the MOD intrinsic (X-INT(X/Y)*Y), not MODULO (which is below).
// 8/5 = 1r3;  -8/5 = -1r-3;  8/-5 = -1r3;  -8/-5 = 1r-3
constexpr QuotientWithRemainder DivideSigned(Integer divisor) const {
  bool dividendIsNegative{IsNegative()};
  bool negateQuotient{dividendIsNegative};
  Ordering divisorOrdering{divisor.CompareToZeroSigned()};
  if (divisorOrdering == Ordering::Less) {
    negateQuotient = !negateQuotient;
    auto negated{divisor.Negate()};
    if (negated.overflow) {
      // divisor was (and is) the most negative number
      if (CompareUnsigned(divisor) == Ordering::Equal) {
        return {MASKR(1), Integer{}, false, bits <= 1};
      } else {
        return {Integer{}, *this, false, false};
      }
    }
    divisor = negated.value;
  } else if (divisorOrdering == Ordering::Equal) {
    // division by zero
    if (dividendIsNegative) {
      return {MASKL(1), Integer{}, true, false};
    } else {
      return {MASKR(bits - 1), Integer{}, true, false};
    }
  }
  Integer dividend{*this};
  if (dividendIsNegative) {
    auto negated{Negate()};
    if (negated.overflow) {
      // Dividend was (and remains) the most negative number.
      // See whether the original divisor was -1 (if so, it's 1 now).
      if (divisorOrdering == Ordering::Less &&
          divisor.CompareUnsigned(Integer{1}) == Ordering::Equal) {
        // most negative number / -1 is the sole overflow case
        return {*this, Integer{}, false, true};
      }
    } else {
      dividend = negated.value;
    }
  }
  // Overflow is not possible, and both the dividend and divisor
  // are now positive.
  QuotientWithRemainder result{dividend.DivideUnsigned(divisor)};
  if (negateQuotient) {
    result.quotient = result.quotient.Negate().value;
  }
  if (dividendIsNegative) {
    result.remainder = result.remainder.Negate().value;
  }
  return result;
}

// Result has the sign of the divisor argument.
// 8 mod 5 = 3;  -8 mod 5 = 2;  8 mod -5 = -2;  -8 mod -5 = -3
constexpr ValueWithOverflow MODULO(const Integer &divisor) const {
  bool negativeDivisor{divisor.IsNegative()};
  bool distinctSigns{IsNegative() != negativeDivisor};
  QuotientWithRemainder divided{DivideSigned(divisor)};
  if (distinctSigns && !divided.remainder.IsZero()) {
    return {divided.remainder.AddUnsigned(divisor).value, divided.overflow};
  } else {
    return {divided.remainder, divided.overflow};
  }
}

constexpr PowerWithErrors Power(const Integer &exponent) const {
  PowerWithErrors result{1, false, false, false};
  if (exponent.IsZero()) {
    // x**0 -> 1, including the case 0**0, which is not defined specifically
    // in F'18 afaict; however, other Fortrans tested all produce 1, not 0,
    // apart from nagfor, which stops with an error at runtime.
    // Ada, APL, C's pow(), Haskell, Julia, MATLAB, and R all produce 1 too.
    // F'77 explicitly states that 0**0 is mathematically undefined and
    // therefore prohibited.
    result.zeroToZero = IsZero();
  } else if (exponent.IsNegative()) {
    if (IsZero()) {
      result.divisionByZero = true;
      result.power = MASKR(bits - 1);
    } else if (CompareSigned(Integer{1}) == Ordering::Equal) {
      result.power = *this; // 1**x -> 1
    } else if (CompareSigned(Integer{-1}) == Ordering::Equal) {
      if (exponent.BTEST(0)) {
        result.power = *this; // (-1)**x -> -1 if x is odd
      }
    } else {
      result.power.Clear(); // j**k -> 0 if |j| > 1 and k < 0
    }
  } else {
    Integer shifted{*this};
    Integer pow{exponent};
    int nbits{bits - pow.LEADZ()};
    for (int j{0}; j < nbits; ++j) {
      if (pow.BTEST(j)) {
        Product product{result.power.MultiplySigned(shifted)};
        result.power = product.lower;
        result.overflow |= product.SignedMultiplicationOverflowed();
      }
      if (j + 1 < nbits) {
        Product squared{shifted.MultiplySigned(shifted)};
        result.overflow |= squared.SignedMultiplicationOverflowed();
        shifted = squared.lower;
      }
    }
  }
  return result;
}

1001private:
// A private constructor, selected by the use of nullptr,
// that is used by member functions when it would be a waste
// of time to initialize parts_[].
constexpr Integer(std::nullptr_t) {}

// Accesses parts in little-endian order.
constexpr const Part &LEPart(int part) const {
  if constexpr (littleEndian42.1
'littleEndian' is true
1
'littleEndian' is true
1
'littleEndian' is true
) {
43
←
Taking true branch→
    return part_[part];
44
←
Returning value→
  } else {
    return part_[parts - 1 - part];
  }
}

constexpr Part &LEPart(int part) {
  if constexpr (littleEndian) {
    return part_[part];
  } else {
    return part_[parts - 1 - part];
  }
}

constexpr void SetLEPart(int part, Part x) {
  LEPart(part) = x & PartMask(part);
}

static constexpr Part PartMask(int part) {
  return part == parts - 1 ? topPartMask : partMask;
}

constexpr void Clear() {
  for (int j{0}; j < parts; ++j) {
    part_[j] = 0;
  }
}

Part part_[parts]{};
1039};

1041extern template class Integer<8>;
1042extern template class Integer<16>;
1043extern template class Integer<32>;
1044extern template class Integer<64>;
1045extern template class Integer<80>;
1046extern template class Integer<128>;
1047} // namespace Fortran::evaluate::value
1048#endif // FORTRAN_EVALUATE_INTEGER_H_