20 using namespace llvm::ScaledNumbers;
25 auto getU = [](uint64_t
N) {
return N >> 32; };
26 auto getL = [](uint64_t
N) {
return N & UINT32_MAX; };
27 uint64_t UL =
getU(LHS), LL = getL(LHS), UR =
getU(RHS), LR = getL(RHS);
30 uint64_t P1 = UL * UR, P2 = UL * LR, P3 = LL * UR, P4 = LL * LR;
33 uint64_t Upper = P1, Lower = P4;
34 auto addWithCarry = [&](uint64_t
N) {
35 uint64_t NewLower = Lower + (getL(
N) << 32);
36 Upper +=
getU(
N) + (NewLower < Lower);
44 return std::make_pair(Lower, 0);
48 int Shift = 64 - LeadingZeros;
50 Upper = Upper << LeadingZeros | Lower >> Shift;
52 Shift && (Lower & UINT64_C(1) << (Shift - 1)));
55 static uint64_t
getHalf(uint64_t
N) {
return (N >> 1) + (N & 1); }
59 assert(Dividend &&
"expected non-zero dividend");
60 assert(Divisor &&
"expected non-zero divisor");
63 uint64_t Dividend64 = Dividend;
69 uint64_t Quotient = Dividend64 / Divisor;
70 uint64_t Remainder = Dividend64 % Divisor;
73 if (Quotient > UINT32_MAX)
74 return getAdjusted<uint32_t>(Quotient, Shift);
77 return getRounded<uint32_t>(Quotient, Shift, Remainder >=
getHalf(Divisor));
82 assert(Dividend &&
"expected non-zero dividend");
83 assert(Divisor &&
"expected non-zero divisor");
94 return std::make_pair(Dividend, Shift);
103 uint64_t Quotient = Dividend / Divisor;
107 while (!(Quotient >> 63) && Dividend) {
109 bool IsOverflow = Dividend >> 63;
115 if (IsOverflow || Divisor <= Dividend) {
125 assert(ScaleDiff >= 0 &&
"wrong argument order");
126 assert(ScaleDiff < 64 &&
"numbers too far apart");
128 uint64_t L_adjusted = L >> ScaleDiff;
134 return L > L_adjusted << ScaleDiff ? 1 : 0;
169 int Shift = 63 - (NewE - E);
170 assert(Shift <= LeadingZeros);
172 assert(Shift >= 0 && Shift < 64 &&
"undefined behavior");
177 unsigned AdjustedE = E + 16383;
184 uint64_t RawBits[2] = {D, AdjustedE};
187 Float.
toString(Chars, Precision, 0);
188 return std::string(Chars.
begin(), Chars.
end());
192 size_t NonZero = Float.find_last_not_of(
'0');
193 assert(NonZero != std::string::npos &&
"no . in floating point string");
195 if (Float[NonZero] ==
'.')
198 return Float.substr(0, NonZero + 1);
202 unsigned Precision) {
214 if (
int Shift =
std::min(int16_t(countLeadingZeros64(D)), E)) {
221 }
else if (E > -64) {
223 Below0 = D << (64 + E);
224 }
else if (E == -64) {
227 }
else if (E > -120) {
228 Below0 = D >> (-E - 64);
229 Extra = D << (128 + E);
230 ExtraShift = -64 - E;
234 if (!Above0 && !Below0)
239 size_t DigitsOut = 0;
242 DigitsOut = Str.size();
245 std::reverse(Str.begin(), Str.end());
253 uint64_t
Error = UINT64_C(1) << (64 - Width);
257 Extra = (Below0 & 0xf) << 56 | (Extra >> 8);
260 size_t AfterDot = Str.size();
270 Below0 += (Extra >> 60);
271 Extra = Extra & (UINT64_MAX >> 4);
273 Below0 = Below0 & (UINT64_MAX >> 4);
274 if (DigitsOut || Str.back() !=
'0')
277 }
while (Error && (Below0 << 4 | Extra >> 60) >= Error / 2 &&
278 (!Precision || DigitsOut <= Precision || SinceDot < 2));
281 if (!Precision || DigitsOut <= Precision)
286 std::max(Str.size() - (DigitsOut - Precision), AfterDot + 1);
289 if (Truncate >= Str.size())
297 for (std::string::reverse_iterator
I(Str.begin() + Truncate), E = Str.rend();
316 int Width,
unsigned Precision) {
317 return OS << toString(D, E, Width, Precision);
321 print(
dbgs(), D, E, Width, 0) <<
"[" << Width <<
":" << D <<
"*2^" << E
static void appendNumber(std::string &Str, uint64_t N)
static void dump(uint64_t D, int16_t E, int Width)
static bool doesRoundUp(char Digit)
std::size_t countLeadingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the most significant bit to the least stopping at the first 1...
const int32_t MaxScale
Maximum scale; same as APFloat for easy debug printing.
static const fltSemantics x87DoubleExtended
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
static int countLeadingZeros64(uint64_t N)
std::pair< DigitsT, int16_t > getRounded(DigitsT Digits, int16_t Scale, bool ShouldRound)
Conditionally round up a scaled number.
static uint64_t getHalf(uint64_t N)
static std::string toStringAPFloat(uint64_t D, int E, unsigned Precision)
static std::string stripTrailingZeros(const std::string &Float)
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
std::size_t countTrailingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the least significant bit to the most stopping at the first 1...
static std::string toString(uint64_t D, int16_t E, int Width, unsigned Precision)
This file declares a class to represent arbitrary precision floating point values and provide a varie...
int compareImpl(uint64_t L, uint64_t R, int ScaleDiff)
Implementation for comparing scaled numbers.
std::pair< uint64_t, int16_t > multiply64(uint64_t LHS, uint64_t RHS)
Multiply two 64-bit integers to create a 64-bit scaled number.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Class for arbitrary precision integers.
static void appendDigit(std::string &Str, unsigned D)
std::pair< uint64_t, int16_t > divide64(uint64_t Dividend, uint64_t Divisor)
Divide two 64-bit integers to create a 64-bit scaled number.
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3) const
Converts this value into a decimal string.
This class implements an extremely fast bulk output stream that can only output to a stream...
std::pair< uint32_t, int16_t > divide32(uint32_t Dividend, uint32_t Divisor)
Divide two 32-bit integers to create a 32-bit scaled number.
const int32_t MinScale
Maximum scale; same as APFloat for easy debug printing.
static raw_ostream & print(raw_ostream &OS, uint64_t D, int16_t E, int Width, unsigned Precision)