Root/detail / dragonbox / emulated128.hpp
Prev Index Next

detail/dragonbox/emulated128.hpp

81.8% Lines (18/22) 83.3% Functions (5/6) -% Branches (0/0)
detail/dragonbox/emulated128.hpp
Line Hits Source Code
1 // Copyright 2020-2023 Daniel Lemire
2 // Copyright 2023 Matt Borland
3 // Distributed under the Boost Software License, Version 1.0.
4 // https://www.boost.org/LICENSE_1_0.txt
5 //
6 // If the architecture (e.g. Apple ARM) does not have __int128 we need to emulate it
7
8 #ifndef BOOST_JSON_DETAIL_DRAGONBOX_EMULATED128_HPP
9 #define BOOST_JSON_DETAIL_DRAGONBOX_EMULATED128_HPP
10
11 #include <boost/json/detail/config.hpp>
12 #include <boost/json/detail/charconv/detail/config.hpp>
13 #include <boost/endian/conversion.hpp>
14 #include <boost/core/bit.hpp>
15 #include <limits>
16 #include <cstdint>
17 #include <cassert>
18 #include <cmath>
19
20 namespace boost {
21 namespace json {
22 namespace detail {
23
24 // Compilers might support built-in 128-bit integer types. However, it seems that
25 // emulating them with a pair of 64-bit integers actually produces a better code,
26 // so we avoid using those built-ins. That said, they are still useful for
27 // implementing 64-bit x 64-bit -> 128-bit multiplication.
28
29 // Memcpy-able temp class for uint128
30 template <boost::endian::order Order = boost::endian::order::little>
31 struct trivial_uint128_impl
32 {
33 std::uint64_t low;
34 std::uint64_t high;
35 };
36
37 template <>
38 struct trivial_uint128_impl<boost::endian::order::big>
39 {
40 std::uint64_t high;
41 std::uint64_t low;
42 };
43
44 using trivial_uint128 = trivial_uint128_impl<boost::endian::order::native>;
45
46 // Macro replacement lists can not be enclosed in parentheses
47 struct uint128
48 {
49 std::uint64_t high;
50 std::uint64_t low;
51
52 // Constructors
53 constexpr uint128() noexcept : high {}, low {} {}
54
55 constexpr uint128(const uint128& v) noexcept = default;
56
57 constexpr uint128(uint128&& v) noexcept = default;
58
59 749 constexpr uint128(std::uint64_t high_, std::uint64_t low_) noexcept : high {high_}, low {low_} {}
60
61 constexpr uint128(const trivial_uint128& v) noexcept : high {v.high}, low {v.low} {} // NOLINT
62
63 constexpr uint128(trivial_uint128&& v) noexcept : high {v.high}, low {v.low} {} // NOLINT
64
65 #define SIGNED_CONSTRUCTOR(expr) constexpr uint128(expr v) noexcept : high {v < 0 ? UINT64_MAX : UINT64_C(0)}, low {static_cast<std::uint64_t>(v)} {} // NOLINT
66 #define UNSIGNED_CONSTRUCTOR(expr) constexpr uint128(expr v) noexcept : high {}, low {static_cast<std::uint64_t>(v)} {} // NOLINT
67
68 SIGNED_CONSTRUCTOR(char) // NOLINT
69 SIGNED_CONSTRUCTOR(signed char) // NOLINT
70 SIGNED_CONSTRUCTOR(short) // NOLINT
71 SIGNED_CONSTRUCTOR(int) // NOLINT
72 SIGNED_CONSTRUCTOR(long) // NOLINT
73 SIGNED_CONSTRUCTOR(long long) // NOLINT
74
75 UNSIGNED_CONSTRUCTOR(unsigned char) // NOLINT
76 UNSIGNED_CONSTRUCTOR(unsigned short) // NOLINT
77 UNSIGNED_CONSTRUCTOR(unsigned) // NOLINT
78 UNSIGNED_CONSTRUCTOR(unsigned long) // NOLINT
79 UNSIGNED_CONSTRUCTOR(unsigned long long) // NOLINT
80
81 #ifdef BOOST_HAS_INT128
82 constexpr uint128(boost::int128_type v) noexcept : // NOLINT : Allow implicit conversions
83 high {static_cast<std::uint64_t>(v >> 64)},
84 low {static_cast<std::uint64_t>(static_cast<boost::uint128_type>(v) & ~UINT64_C(0))} {}
85
86 constexpr uint128(boost::uint128_type v) noexcept : // NOLINT : Allow implicit conversions
87 high {static_cast<std::uint64_t>(v >> 64)},
88 low {static_cast<std::uint64_t>(v & ~UINT64_C(0))} {}
89 #endif
90
91 #undef SIGNED_CONSTRUCTOR
92 #undef UNSIGNED_CONSTRUCTOR
93
94 // Assignment Operators
95 #define SIGNED_ASSIGNMENT_OPERATOR(expr) BOOST_JSON_CXX14_CONSTEXPR uint128 &operator=(const expr& v) noexcept { high = v < 0 ? UINT64_MAX : UINT64_C(0); low = static_cast<std::uint64_t>(v); return *this; } // NOLINT
96 #define UNSIGNED_ASSIGNMENT_OPERATOR(expr) BOOST_JSON_CXX14_CONSTEXPR uint128 &operator=(const expr& v) noexcept { high = 0U; low = static_cast<std::uint64_t>(v); return *this; } // NOLINT
97
98 SIGNED_ASSIGNMENT_OPERATOR(char) // NOLINT
99 SIGNED_ASSIGNMENT_OPERATOR(signed char) // NOLINT
100 SIGNED_ASSIGNMENT_OPERATOR(short) // NOLINT
101 SIGNED_ASSIGNMENT_OPERATOR(int) // NOLINT
102 SIGNED_ASSIGNMENT_OPERATOR(long) // NOLINT
103 SIGNED_ASSIGNMENT_OPERATOR(long long) // NOLINT
104
105 UNSIGNED_ASSIGNMENT_OPERATOR(unsigned char) // NOLINT
106 UNSIGNED_ASSIGNMENT_OPERATOR(unsigned short) // NOLINT
107 UNSIGNED_ASSIGNMENT_OPERATOR(unsigned) // NOLINT
108 UNSIGNED_ASSIGNMENT_OPERATOR(unsigned long) // NOLINT
109 UNSIGNED_ASSIGNMENT_OPERATOR(unsigned long long) // NOLINT
110
111 #ifdef BOOST_HAS_INT128
112 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator=(const boost::int128_type& v) noexcept { *this = uint128(v); return *this; }
113 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator=(const boost::uint128_type& v) noexcept { *this = uint128(v); return *this; }
114 #endif
115
116 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator=(const trivial_uint128& v) noexcept { this->low = v.low; this->high = v.high; return *this; }
117
118 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator=(const uint128&) noexcept;
119
120 #undef SIGNED_ASSIGNMENT_OPERATOR
121 #undef UNSIGNED_ASSIGNMENT_OPERATOR
122
123 // Conversion Operators
124 #define INTEGER_CONVERSION_OPERATOR(expr) explicit constexpr operator expr() const noexcept { return static_cast<expr>(low); } // NOLINT
125 #define FLOAT_CONVERSION_OPERATOR(expr) explicit operator expr() const noexcept { return std::ldexp(static_cast<expr>(high), 64) + static_cast<expr>(low); } // NOLINT
126
127 INTEGER_CONVERSION_OPERATOR(char) // NOLINT
128 INTEGER_CONVERSION_OPERATOR(signed char) // NOLINT
129 INTEGER_CONVERSION_OPERATOR(short) // NOLINT
130 INTEGER_CONVERSION_OPERATOR(int) // NOLINT
131 INTEGER_CONVERSION_OPERATOR(long) // NOLINT
132 INTEGER_CONVERSION_OPERATOR(long long) // NOLINT
133 INTEGER_CONVERSION_OPERATOR(unsigned char) // NOLINT
134 INTEGER_CONVERSION_OPERATOR(unsigned short) // NOLINT
135 INTEGER_CONVERSION_OPERATOR(unsigned) // NOLINT
136 INTEGER_CONVERSION_OPERATOR(unsigned long) // NOLINT
137 INTEGER_CONVERSION_OPERATOR(unsigned long long) // NOLINT
138
139 explicit constexpr operator bool() const noexcept { return high || low; }
140
141 #ifdef BOOST_HAS_INT128
142 explicit constexpr operator boost::int128_type() const noexcept { return (static_cast<boost::int128_type>(high) << 64) + low; }
143 explicit constexpr operator boost::uint128_type() const noexcept { return (static_cast<boost::uint128_type>(high) << 64) + low; }
144 #endif
145
146 FLOAT_CONVERSION_OPERATOR(float) // NOLINT
147 FLOAT_CONVERSION_OPERATOR(double) // NOLINT
148 FLOAT_CONVERSION_OPERATOR(long double) // NOLINT
149
150 #undef INTEGER_CONVERSION_OPERATOR
151 #undef FLOAT_CONVERSION_OPERATOR
152
153 // Unary Operators
154 constexpr friend uint128 operator-(uint128 val) noexcept;
155 constexpr friend uint128 operator+(uint128 val) noexcept;
156
157 // Comparison Operators
158
159 // Equality
160 #define INTEGER_OPERATOR_EQUAL(expr) constexpr friend bool operator==(uint128 lhs, expr rhs) noexcept { return lhs.high == 0 && rhs >= 0 && lhs.low == static_cast<std::uint64_t>(rhs); } // NOLINT
161 #define UNSIGNED_INTEGER_OPERATOR_EQUAL(expr) constexpr friend bool operator==(uint128 lhs, expr rhs) noexcept { return lhs.high == 0 && lhs.low == static_cast<std::uint64_t>(rhs); } // NOLINT
162
163 INTEGER_OPERATOR_EQUAL(char) // NOLINT
164 INTEGER_OPERATOR_EQUAL(signed char) // NOLINT
165 INTEGER_OPERATOR_EQUAL(short) // NOLINT
166 INTEGER_OPERATOR_EQUAL(int) // NOLINT
167 INTEGER_OPERATOR_EQUAL(long) // NOLINT
168 INTEGER_OPERATOR_EQUAL(long long) // NOLINT
169 UNSIGNED_INTEGER_OPERATOR_EQUAL(unsigned char) // NOLINT
170 UNSIGNED_INTEGER_OPERATOR_EQUAL(unsigned short) // NOLINT
171 UNSIGNED_INTEGER_OPERATOR_EQUAL(unsigned) // NOLINT
172 UNSIGNED_INTEGER_OPERATOR_EQUAL(unsigned long) // NOLINT
173 UNSIGNED_INTEGER_OPERATOR_EQUAL(unsigned long long) // NOLINT
174
175 #ifdef BOOST_HAS_INT128
176 constexpr friend bool operator==(uint128 lhs, boost::int128_type rhs) noexcept { return lhs == uint128(rhs); }
177 constexpr friend bool operator==(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs == uint128(rhs); }
178 #endif
179
180 constexpr friend bool operator==(uint128 lhs, uint128 rhs) noexcept;
181
182 #undef INTEGER_OPERATOR_EQUAL
183 #undef UNSIGNED_INTEGER_OPERATOR_EQUAL
184
185 // Inequality
186 #define INTEGER_OPERATOR_NOTEQUAL(expr) constexpr friend bool operator!=(uint128 lhs, expr rhs) noexcept { return !(lhs == rhs); } // NOLINT
187
188 INTEGER_OPERATOR_NOTEQUAL(char) // NOLINT
189 INTEGER_OPERATOR_NOTEQUAL(signed char) // NOLINT
190 INTEGER_OPERATOR_NOTEQUAL(short) // NOLINT
191 INTEGER_OPERATOR_NOTEQUAL(int) // NOLINT
192 INTEGER_OPERATOR_NOTEQUAL(long) // NOLINT
193 INTEGER_OPERATOR_NOTEQUAL(long long) // NOLINT
194 INTEGER_OPERATOR_NOTEQUAL(unsigned char) // NOLINT
195 INTEGER_OPERATOR_NOTEQUAL(unsigned short) // NOLINT
196 INTEGER_OPERATOR_NOTEQUAL(unsigned) // NOLINT
197 INTEGER_OPERATOR_NOTEQUAL(unsigned long) // NOLINT
198 INTEGER_OPERATOR_NOTEQUAL(unsigned long long) // NOLINT
199
200 #ifdef BOOST_HAS_INT128
201 constexpr friend bool operator!=(uint128 lhs, boost::int128_type rhs) noexcept { return !(lhs == rhs); }
202 constexpr friend bool operator!=(uint128 lhs, boost::uint128_type rhs) noexcept { return !(lhs == rhs); }
203 #endif
204
205 constexpr friend bool operator!=(uint128 lhs, uint128 rhs) noexcept;
206
207 #undef INTEGER_OPERATOR_NOTEQUAL
208
209 // Less than
210 #define INTEGER_OPERATOR_LESS_THAN(expr) constexpr friend bool operator<(uint128 lhs, expr rhs) noexcept { return lhs.high == 0U && rhs > 0 && lhs.low < static_cast<std::uint64_t>(rhs); } // NOLINT
211 #define UNSIGNED_INTEGER_OPERATOR_LESS_THAN(expr) constexpr friend bool operator<(uint128 lhs, expr rhs) noexcept { return lhs.high == 0U && lhs.low < static_cast<std::uint64_t>(rhs); } // NOLINT
212
213 INTEGER_OPERATOR_LESS_THAN(char) // NOLINT
214 INTEGER_OPERATOR_LESS_THAN(signed char) // NOLINT
215 INTEGER_OPERATOR_LESS_THAN(short) // NOLINT
216 INTEGER_OPERATOR_LESS_THAN(int) // NOLINT
217 INTEGER_OPERATOR_LESS_THAN(long) // NOLINT
218 INTEGER_OPERATOR_LESS_THAN(long long) // NOLINT
219 UNSIGNED_INTEGER_OPERATOR_LESS_THAN(unsigned char) // NOLINT
220 UNSIGNED_INTEGER_OPERATOR_LESS_THAN(unsigned short) // NOLINT
221 UNSIGNED_INTEGER_OPERATOR_LESS_THAN(unsigned) // NOLINT
222 UNSIGNED_INTEGER_OPERATOR_LESS_THAN(unsigned long) // NOLINT
223 UNSIGNED_INTEGER_OPERATOR_LESS_THAN(unsigned long long) // NOLINT
224
225 #ifdef BOOST_HAS_INT128
226 BOOST_JSON_CXX14_CONSTEXPR friend bool operator<(uint128 lhs, boost::int128_type rhs) noexcept { return lhs < uint128(rhs); }
227 BOOST_JSON_CXX14_CONSTEXPR friend bool operator<(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs < uint128(rhs); }
228 #endif
229
230 BOOST_JSON_CXX14_CONSTEXPR friend bool operator<(uint128 lhs, uint128 rhs) noexcept;
231
232 #undef INTEGER_OPERATOR_LESS_THAN
233 #undef UNSIGNED_INTEGER_OPERATOR_LESS_THAN
234
235 // Less than or equal to
236 #define INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(expr) constexpr friend bool operator<=(uint128 lhs, expr rhs) noexcept { return lhs.high == 0U && rhs >= 0 && lhs.low <= static_cast<std::uint64_t>(rhs); } // NOLINT
237 #define UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(expr) constexpr friend bool operator<=(uint128 lhs, expr rhs) noexcept { return lhs.high == 0U && lhs.low <= static_cast<std::uint64_t>(rhs); } // NOLINT
238
239 INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(char) // NOLINT
240 INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(signed char) // NOLINT
241 INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(short) // NOLINT
242 INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(int) // NOLINT
243 INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(long) // NOLINT
244 INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(long long) // NOLINT
245 UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(unsigned char) // NOLINT
246 UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(unsigned short) // NOLINT
247 UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(unsigned) // NOLINT
248 UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(unsigned long) // NOLINT
249 UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO(unsigned long long) // NOLINT
250
251 #ifdef BOOST_HAS_INT128
252 BOOST_JSON_CXX14_CONSTEXPR friend bool operator<=(uint128 lhs, boost::int128_type rhs) noexcept { return lhs <= uint128(rhs); }
253 BOOST_JSON_CXX14_CONSTEXPR friend bool operator<=(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs <= uint128(rhs); }
254 #endif
255
256 BOOST_JSON_CXX14_CONSTEXPR friend bool operator<=(uint128 lhs, uint128 rhs) noexcept;
257
258 #undef INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO
259 #undef UNSIGNED_INTEGER_OPERATOR_LESS_THAN_OR_EQUAL_TO
260
261 // Greater than
262 #define INTEGER_OPERATOR_GREATER_THAN(expr) constexpr friend bool operator>(uint128 lhs, expr rhs) noexcept { return lhs.high > 0U || rhs < 0 || lhs.low > static_cast<std::uint64_t>(rhs); } // NOLINT
263 #define UNSIGNED_INTEGER_OPERATOR_GREATER_THAN(expr) constexpr friend bool operator>(uint128 lhs, expr rhs) noexcept { return lhs.high > 0U || lhs.low > static_cast<std::uint64_t>(rhs); } // NOLINT
264
265 INTEGER_OPERATOR_GREATER_THAN(char) // NOLINT
266 INTEGER_OPERATOR_GREATER_THAN(signed char) // NOLINT
267 INTEGER_OPERATOR_GREATER_THAN(short) // NOLINT
268 INTEGER_OPERATOR_GREATER_THAN(int) // NOLINT
269 INTEGER_OPERATOR_GREATER_THAN(long) // NOLINT
270 INTEGER_OPERATOR_GREATER_THAN(long long) // NOLINT
271 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN(unsigned char) // NOLINT
272 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN(unsigned short) // NOLINT
273 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN(unsigned) // NOLINT
274 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN(unsigned long) // NOLINT
275 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN(unsigned long long) // NOLINT
276
277 #ifdef BOOST_HAS_INT128
278 BOOST_JSON_CXX14_CONSTEXPR friend bool operator>(uint128 lhs, boost::int128_type rhs) noexcept { return lhs > uint128(rhs); }
279 BOOST_JSON_CXX14_CONSTEXPR friend bool operator>(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs > uint128(rhs); }
280 #endif
281
282 BOOST_JSON_CXX14_CONSTEXPR friend bool operator>(uint128 lhs, uint128 rhs) noexcept;
283
284 #undef INTEGER_OPERATOR_GREATER_THAN
285 #undef UNSIGNED_INTEGER_OPERATOR_GREATER_THAN
286
287 // Greater than or equal to
288 #define INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(expr) constexpr friend bool operator>=(uint128 lhs, expr rhs) noexcept { return lhs.high > 0U || rhs < 0 || lhs.low >= static_cast<std::uint64_t>(rhs); } // NOLINT
289 #define UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(expr) constexpr friend bool operator>=(uint128 lhs, expr rhs) noexcept { return lhs.high > 0U || lhs.low >= static_cast<std::uint64_t>(rhs); } // NOLINT
290
291 INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(char) // NOLINT
292 INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(signed char) // NOLINT
293 INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(short) // NOLINT
294 INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(int) // NOLINT
295 INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(long) // NOLINT
296 INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(long long) // NOLINT
297 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(unsigned char) // NOLINT
298 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(unsigned short) // NOLINT
299 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(unsigned) // NOLINT
300 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(unsigned long) // NOLINT
301 UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO(unsigned long long) // NOLINT
302
303 #ifdef BOOST_HAS_INT128
304 BOOST_JSON_CXX14_CONSTEXPR friend bool operator>=(uint128 lhs, boost::int128_type rhs) noexcept { return lhs >= uint128(rhs); }
305 BOOST_JSON_CXX14_CONSTEXPR friend bool operator>=(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs >= uint128(rhs); }
306 #endif
307
308 BOOST_JSON_CXX14_CONSTEXPR friend bool operator>=(uint128 lhs, uint128 rhs) noexcept;
309
310 #undef INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO
311 #undef UNSIGNED_INTEGER_OPERATOR_GREATER_THAN_OR_EQUAL_TO
312
313 // Binary Operators
314
315 // Not
316 constexpr friend uint128 operator~(uint128 v) noexcept;
317
318 // Or
319 #define INTEGER_BINARY_OPERATOR_OR(expr) constexpr friend uint128 operator|(uint128 lhs, expr rhs) noexcept { return {lhs.high, lhs.low | static_cast<std::uint64_t>(rhs)}; } // NOLINT
320
321 INTEGER_BINARY_OPERATOR_OR(char) // NOLINT
322 INTEGER_BINARY_OPERATOR_OR(signed char) // NOLINT
323 INTEGER_BINARY_OPERATOR_OR(short) // NOLINT
324 INTEGER_BINARY_OPERATOR_OR(int) // NOLINT
325 INTEGER_BINARY_OPERATOR_OR(long) // NOLINT
326 INTEGER_BINARY_OPERATOR_OR(long long) // NOLINT
327 INTEGER_BINARY_OPERATOR_OR(unsigned char) // NOLINT
328 INTEGER_BINARY_OPERATOR_OR(unsigned short) // NOLINT
329 INTEGER_BINARY_OPERATOR_OR(unsigned) // NOLINT
330 INTEGER_BINARY_OPERATOR_OR(unsigned long) // NOLINT
331 INTEGER_BINARY_OPERATOR_OR(unsigned long long) // NOLINT
332
333 #ifdef BOOST_HAS_INT128
334 constexpr friend uint128 operator|(uint128 lhs, boost::int128_type rhs) noexcept { return lhs | uint128(rhs); }
335 constexpr friend uint128 operator|(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs | uint128(rhs); }
336 #endif
337
338 constexpr friend uint128 operator|(uint128 lhs, uint128 rhs) noexcept;
339
340 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator|=(uint128 v) noexcept;
341
342 #undef INTEGER_BINARY_OPERATOR_OR
343
344 // And
345 #define INTEGER_BINARY_OPERATOR_AND(expr) constexpr friend uint128 operator&(uint128 lhs, expr rhs) noexcept { return {lhs.high, lhs.low & static_cast<std::uint64_t>(rhs)}; } // NOLINT
346
347 INTEGER_BINARY_OPERATOR_AND(char) // NOLINT
348 INTEGER_BINARY_OPERATOR_AND(signed char) // NOLINT
349 INTEGER_BINARY_OPERATOR_AND(short) // NOLINT
350 INTEGER_BINARY_OPERATOR_AND(int) // NOLINT
351 INTEGER_BINARY_OPERATOR_AND(long) // NOLINT
352 INTEGER_BINARY_OPERATOR_AND(long long) // NOLINT
353 INTEGER_BINARY_OPERATOR_AND(unsigned char) // NOLINT
354 INTEGER_BINARY_OPERATOR_AND(unsigned short) // NOLINT
355 INTEGER_BINARY_OPERATOR_AND(unsigned) // NOLINT
356 INTEGER_BINARY_OPERATOR_AND(unsigned long) // NOLINT
357 INTEGER_BINARY_OPERATOR_AND(unsigned long long) // NOLINT
358
359 #ifdef BOOST_HAS_INT128
360 constexpr friend uint128 operator&(uint128 lhs, boost::int128_type rhs) noexcept { return lhs & uint128(rhs); }
361 constexpr friend uint128 operator&(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs & uint128(rhs); }
362 #endif
363
364 constexpr friend uint128 operator&(uint128 lhs, uint128 rhs) noexcept;
365
366 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator&=(uint128 v) noexcept;
367
368 #undef INTEGER_BINARY_OPERATOR_AND
369
370 // Xor
371 #define INTEGER_BINARY_OPERATOR_XOR(expr) constexpr friend uint128 operator^(uint128 lhs, expr rhs) noexcept { return {lhs.high, lhs.low ^ static_cast<std::uint64_t>(rhs)}; } // NOLINT
372
373 INTEGER_BINARY_OPERATOR_XOR(char) // NOLINT
374 INTEGER_BINARY_OPERATOR_XOR(signed char) // NOLINT
375 INTEGER_BINARY_OPERATOR_XOR(short) // NOLINT
376 INTEGER_BINARY_OPERATOR_XOR(int) // NOLINT
377 INTEGER_BINARY_OPERATOR_XOR(long) // NOLINT
378 INTEGER_BINARY_OPERATOR_XOR(long long) // NOLINT
379 INTEGER_BINARY_OPERATOR_XOR(unsigned char) // NOLINT
380 INTEGER_BINARY_OPERATOR_XOR(unsigned short) // NOLINT
381 INTEGER_BINARY_OPERATOR_XOR(unsigned) // NOLINT
382 INTEGER_BINARY_OPERATOR_XOR(unsigned long) // NOLINT
383 INTEGER_BINARY_OPERATOR_XOR(unsigned long long) // NOLINT
384
385 #ifdef BOOST_HAS_INT128
386 constexpr friend uint128 operator^(uint128 lhs, boost::int128_type rhs) noexcept { return lhs ^ uint128(rhs); }
387 constexpr friend uint128 operator^(uint128 lhs, boost::uint128_type rhs) noexcept { return lhs ^ uint128(rhs); }
388 #endif
389
390 constexpr friend uint128 operator^(uint128 lhs, uint128 rhs) noexcept;
391
392 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator^=(uint128 v) noexcept;
393
394 #undef INTEGER_BINARY_OPERATOR_XOR
395
396 // Left shift
397 #define INTEGER_BINARY_OPERATOR_LEFT_SHIFT(expr) \
398 BOOST_CXX14_CONSTEXPR friend uint128 operator<<(uint128 lhs, expr rhs) noexcept \
399 { \
400 if (rhs >= 64) \
401 { \
402 return {lhs.low << (rhs - 64), 0}; \
403 } \
404 else if (rhs == 0) \
405 { \
406 return lhs; \
407 } \
408 \
409 return {(lhs.high << rhs) | (lhs.low >> (64 - rhs)), lhs.low << rhs}; \
410 } // NOLINT
411
412 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(char) // NOLINT
413 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(signed char) // NOLINT
414 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(short) // NOLINT
415 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(int) // NOLINT
416 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(long) // NOLINT
417 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(long long) // NOLINT
418 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(unsigned char) // NOLINT
419 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(unsigned short) // NOLINT
420 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(unsigned) // NOLINT
421 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(unsigned long) // NOLINT
422 INTEGER_BINARY_OPERATOR_LEFT_SHIFT(unsigned long long) // NOLINT
423
424 #define INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(expr) \
425 BOOST_CXX14_CONSTEXPR uint128 &operator<<=(expr amount) noexcept \
426 { \
427 *this = *this << amount; \
428 return *this; \
429 } // NOLINT
430
431 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(char) // NOLINT
432 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(signed char) // NOLINT
433 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(short) // NOLINT
434 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(int) // NOLINT
435 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(long) // NOLINT
436 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(long long) // NOLINT
437 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(unsigned char) // NOLINT
438 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(unsigned short) // NOLINT
439 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(unsigned) // NOLINT
440 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(unsigned long) // NOLINT
441 INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT(unsigned long long) // NOLINT
442
443 #undef INTEGER_BINARY_OPERATOR_LEFT_SHIFT
444 #undef INTEGER_BINARY_OPERATOR_EQUALS_LEFT_SHIFT
445
446 // Right Shift
447 #define INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(expr) \
448 BOOST_CXX14_CONSTEXPR friend uint128 operator>>(uint128 lhs, expr amount) noexcept \
449 { \
450 if (amount >= 64) \
451 { \
452 return {0, lhs.high >> (amount - 64)}; \
453 } \
454 else if (amount == 0) \
455 { \
456 return lhs; \
457 } \
458 \
459 return {lhs.high >> amount, (lhs.low >> amount) | (lhs.high << (64 - amount))}; \
460 } // NOLINT
461
462 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(char) // NOLINT
463 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(signed char) // NOLINT
464 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(short) // NOLINT
465 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(int) // NOLINT
466 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(long) // NOLINT
467 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(long long) // NOLINT
468 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(unsigned char) // NOLINT
469 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(unsigned short) // NOLINT
470 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(unsigned) // NOLINT
471 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(unsigned long) // NOLINT
472 INTEGER_BINARY_OPERATOR_RIGHT_SHIFT(unsigned long long) // NOLINT
473
474 #define INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(expr) \
475 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator>>=(expr amount) noexcept \
476 { \
477 *this = *this >> amount; \
478 return *this; \
479 } // NOLINT
480
481 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(char) // NOLINT
482 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(signed char) // NOLINT
483 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(short) // NOLINT
484 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(int) // NOLINT
485 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(long) // NOLINT
486 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(long long) // NOLINT
487 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(unsigned char) // NOLINT
488 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(unsigned short) // NOLINT
489 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(unsigned) // NOLINT
490 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(unsigned long) // NOLINT
491 INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT(unsigned long long) // NOLINT
492
493 #undef INTEGER_BINARY_OPERATOR_RIGHT_SHIFT
494 #undef INTEGER_BINARY_OPERATOR_EQUALS_RIGHT_SHIFT
495
496 // Arithmetic operators (Add, sub, mul, div, mod)
497 inline uint128 &operator+=(std::uint64_t n) noexcept;
498
499 BOOST_JSON_CXX14_CONSTEXPR friend uint128 operator+(uint128 lhs, uint128 rhs) noexcept;
500
501 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator+=(uint128 v) noexcept;
502
503 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator++() noexcept;
504
505 BOOST_JSON_CXX14_CONSTEXPR const uint128 operator++(int) noexcept;
506
507 BOOST_JSON_CXX14_CONSTEXPR friend uint128 operator-(uint128 lhs, uint128 rhs) noexcept;
508
509 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator-=(uint128 v) noexcept;
510
511 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator--() noexcept;
512
513 BOOST_JSON_CXX14_CONSTEXPR const uint128 operator--(int) noexcept;
514
515 BOOST_JSON_CXX14_CONSTEXPR friend uint128 operator*(uint128 lhs, uint128 rhs) noexcept;
516
517 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator*=(uint128 v) noexcept;
518
519 BOOST_JSON_CXX14_CONSTEXPR friend uint128 operator/(uint128 lhs, uint128 rhs) noexcept;
520
521 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator/=(uint128 v) noexcept;
522
523 BOOST_JSON_CXX14_CONSTEXPR friend uint128 operator%(uint128 lhs, uint128 rhs) noexcept;
524
525 BOOST_JSON_CXX14_CONSTEXPR uint128 &operator%=(uint128 v) noexcept;
526
527 private:
528 BOOST_JSON_CXX14_CONSTEXPR friend int high_bit(uint128 v) noexcept;
529
530 BOOST_JSON_CXX14_CONSTEXPR friend void
531 div_impl(uint128 lhs, uint128 rhs, uint128 &quotient, uint128 &remainder) noexcept;
532 };
533
534 constexpr uint128 operator-(uint128 val) noexcept
535 {
536 return {~val.high + static_cast<std::uint64_t>(val.low == 0), ~val.low + 1};
537 }
538
539 constexpr uint128 operator+(uint128 val) noexcept
540 {
541 return val;
542 }
543
544 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator=(const uint128& v) noexcept // NOLINT : User defined for older compilers
545 {
546 low = v.low;
547 high = v.high;
548 return *this;
549 }
550
551 constexpr bool operator==(uint128 lhs, uint128 rhs) noexcept
552 {
553 return lhs.high == rhs.high && lhs.low == rhs.low;
554 }
555
556 constexpr bool operator!=(uint128 lhs, uint128 rhs) noexcept
557 {
558 return !(lhs == rhs);
559 }
560
561 BOOST_JSON_CXX14_CONSTEXPR bool operator<(uint128 lhs, uint128 rhs) noexcept
562 {
563 if (lhs.high == rhs.high)
564 {
565 return lhs.low < rhs.low;
566 }
567
568 return lhs.high < rhs.high;
569 }
570
571 BOOST_JSON_CXX14_CONSTEXPR bool operator<=(uint128 lhs, uint128 rhs) noexcept
572 {
573 return !(rhs < lhs);
574 }
575
576 BOOST_JSON_CXX14_CONSTEXPR bool operator>(uint128 lhs, uint128 rhs) noexcept
577 {
578 return rhs < lhs;
579 }
580
581 BOOST_JSON_CXX14_CONSTEXPR bool operator>=(uint128 lhs, uint128 rhs) noexcept
582 {
583 return !(lhs < rhs);
584 }
585
586 constexpr uint128 operator~(uint128 v) noexcept
587 {
588 return {~v.high, ~v.low};
589 }
590
591 constexpr uint128 operator|(uint128 lhs, uint128 rhs) noexcept
592 {
593 return {lhs.high | rhs.high, lhs.low | rhs.low};
594 }
595
596 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator|=(uint128 v) noexcept
597 {
598 *this = *this | v;
599 return *this;
600 }
601
602 constexpr uint128 operator&(uint128 lhs, uint128 rhs) noexcept
603 {
604 return {lhs.high & rhs.high, lhs.low & rhs.low};
605 }
606
607 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator&=(uint128 v) noexcept
608 {
609 *this = *this & v;
610 return *this;
611 }
612
613 constexpr uint128 operator^(uint128 lhs, uint128 rhs) noexcept
614 {
615 return {lhs.high ^ rhs.high, lhs.low ^ rhs.low};
616 }
617
618 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator^=(uint128 v) noexcept
619 {
620 *this = *this ^ v;
621 return *this;
622 }
623
624 306 inline uint128 &uint128::operator+=(std::uint64_t n) noexcept
625 {
626 #if BOOST_JSON_HAS_BUILTIN(__builtin_addcll)
627
628 unsigned long long carry {};
629 low = __builtin_addcll(low, n, 0, &carry);
630 high = __builtin_addcll(high, 0, carry, &carry);
631
632 #elif BOOST_JSON_HAS_BUILTIN(__builtin_ia32_addcarryx_u64)
633
634 306 unsigned long long result {};
635 306 auto carry = __builtin_ia32_addcarryx_u64(0, low, n, &result);
636 306 low = result;
637 306 __builtin_ia32_addcarryx_u64(carry, high, 0, &result);
638 306 high = result;
639
640 #elif defined(BOOST_MSVC) && defined(_M_X64)
641
642 auto carry = _addcarry_u64(0, low, n, &low);
643 _addcarry_u64(carry, high, 0, &high);
644
645 #else
646
647 auto sum = low + n;
648 high += (sum < low ? 1 : 0);
649 low = sum;
650
651 #endif
652 306 return *this;
653 }
654
655 BOOST_JSON_CXX14_CONSTEXPR uint128 operator+(uint128 lhs, uint128 rhs) noexcept
656 {
657 const uint128 temp = {lhs.high + rhs.high, lhs.low + rhs.low};
658
659 // Need to carry a bit into rhs
660 if (temp.low < lhs.low)
661 {
662 return {temp.high + 1, temp.low};
663 }
664
665 return temp;
666 }
667
668 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator+=(uint128 v) noexcept
669 {
670 *this = *this + v;
671 return *this;
672 }
673
674 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator++() noexcept
675 {
676 if (this->low == UINT64_MAX)
677 {
678 this->low = 0;
679 ++this->high;
680 }
681 else
682 {
683 ++this->low;
684 }
685
686 return *this;
687 }
688
689 BOOST_JSON_CXX14_CONSTEXPR const uint128 uint128::operator++(int) noexcept
690 {
691 return ++(*this);
692 }
693
694 BOOST_JSON_CXX14_CONSTEXPR uint128 operator-(uint128 lhs, uint128 rhs) noexcept
695 {
696 const uint128 temp {lhs.high - rhs.high, lhs.low - rhs.low};
697
698 // Check for carry
699 if (lhs.low < rhs.low)
700 {
701 return {temp.high - 1, temp.low};
702 }
703
704 return temp;
705 }
706
707 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator-=(uint128 v) noexcept
708 {
709 *this = *this - v;
710 return *this;
711 }
712
713 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator--() noexcept
714 {
715 if (this->low == 0)
716 {
717 this->low = UINT64_MAX;
718 --this->high;
719 }
720 else // NOLINT
721 {
722 --this->low;
723 }
724
725 return *this;
726 }
727
728 BOOST_JSON_CXX14_CONSTEXPR const uint128 uint128::operator--(int) noexcept
729 {
730 return --(*this);
731 }
732 BOOST_JSON_CXX14_CONSTEXPR uint128 operator*(uint128 lhs, uint128 rhs) noexcept
733 {
734 const auto a = static_cast<std::uint64_t>(lhs.low >> 32);
735 const auto b = static_cast<std::uint64_t>(lhs.low & UINT32_MAX);
736 const auto c = static_cast<std::uint64_t>(rhs.low >> 32);
737 const auto d = static_cast<std::uint64_t>(rhs.low & UINT32_MAX);
738
739 uint128 result { lhs.high * rhs.low + lhs.low * rhs.high + a * c, b * d };
740 result += uint128(a * d) << 32;
741 result += uint128(b * c) << 32;
742 return result;
743 }
744
745 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator*=(uint128 v) noexcept
746 {
747 *this = *this * v;
748 return *this;
749 }
750
751 BOOST_JSON_CXX14_CONSTEXPR int high_bit(uint128 v) noexcept
752 {
753 if (v.high != 0)
754 {
755 return 127 - boost::core::countl_zero(v.high);
756 }
757 else if (v.low != 0)
758 {
759 return 63 - boost::core::countl_zero(v.low);
760 }
761
762 return 0;
763 }
764
765 // See: https://stackoverflow.com/questions/5386377/division-without-using
766 BOOST_JSON_CXX14_CONSTEXPR void div_impl(uint128 lhs, uint128 rhs, uint128& quotient, uint128& remainder) noexcept
767 {
768 constexpr uint128 one {0, 1};
769
770 if (rhs > lhs)
771 {
772 quotient = 0U;
773 remainder = 0U;
774 }
775 else if (lhs == rhs)
776 {
777 quotient = 1U;
778 remainder = 0U;
779 }
780
781 uint128 denom = rhs;
782 quotient = 0U;
783
784 std::int32_t shift = high_bit(lhs) - high_bit(rhs);
785 if (shift < 0)
786 {
787 shift = 32 - shift;
788 }
789 denom <<= shift;
790
791 for (int i = 0; i <= shift; ++i)
792 {
793 quotient <<= 1;
794 if (lhs >= denom)
795 {
796 lhs -= denom;
797 quotient |= one;
798 }
799 denom >>= 1;
800 }
801
802 remainder = lhs;
803 }
804
805 BOOST_JSON_CXX14_CONSTEXPR uint128 operator/(uint128 lhs, uint128 rhs) noexcept
806 {
807 uint128 quotient {0, 0};
808 uint128 remainder {0, 0};
809 div_impl(lhs, rhs, quotient, remainder);
810
811 return quotient;
812 }
813
814 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator/=(uint128 v) noexcept
815 {
816 *this = *this / v;
817 return *this;
818 }
819
820 BOOST_JSON_CXX14_CONSTEXPR uint128 operator%(uint128 lhs, uint128 rhs) noexcept
821 {
822 uint128 quotient {0, 0};
823 uint128 remainder {0, 0};
824 div_impl(lhs, rhs, quotient, remainder);
825
826 return remainder;
827 }
828
829 BOOST_JSON_CXX14_CONSTEXPR uint128 &uint128::operator%=(uint128 v) noexcept
830 {
831 *this = *this % v;
832 return *this;
833 }
834
835 static inline std::uint64_t umul64(std::uint32_t x, std::uint32_t y) noexcept
836 {
837 // __emulu is not available on ARM https://learn.microsoft.com/en-us/cpp/intrinsics/emul-emulu?view=msvc-170
838 #if defined(BOOST_JSON_HAS_MSVC_32BIT_INTRINSICS) && !defined(_M_ARM)
839
840 return __emulu(x, y);
841
842 #else
843
844 return x * static_cast<std::uint64_t>(y);
845
846 #endif
847 }
848
849 // Get 128-bit result of multiplication of two 64-bit unsigned integers.
850 749 BOOST_JSON_SAFEBUFFERS inline uint128 umul128(std::uint64_t x, std::uint64_t y) noexcept
851 {
852 #if defined(BOOST_HAS_INT128)
853
854 749 auto result = static_cast<boost::uint128_type>(x) * static_cast<boost::uint128_type>(y);
855 749 return {static_cast<std::uint64_t>(result >> 64), static_cast<std::uint64_t>(result)};
856
857 // _umul128 is x64 only https://learn.microsoft.com/en-us/cpp/intrinsics/umul128?view=msvc-170
858 #elif defined(BOOST_JSON_HAS_MSVC_64BIT_INTRINSICS) && !defined(_M_ARM64)
859
860 unsigned long long high;
861 std::uint64_t low = _umul128(x, y, &high);
862 return {static_cast<std::uint64_t>(high), low};
863
864 // https://developer.arm.com/documentation/dui0802/a/A64-General-Instructions/UMULH
865 #elif defined(_M_ARM64) && !defined(__MINGW32__)
866
867 std::uint64_t high = __umulh(x, y);
868 std::uint64_t low = x * y;
869 return {high, low};
870
871 #else
872
873 auto a = static_cast<std::uint32_t>(x >> 32);
874 auto b = static_cast<std::uint32_t>(x);
875 auto c = static_cast<std::uint32_t>(y >> 32);
876 auto d = static_cast<std::uint32_t>(y);
877
878 auto ac = umul64(a, c);
879 auto bc = umul64(b, c);
880 auto ad = umul64(a, d);
881 auto bd = umul64(b, d);
882
883 auto intermediate = (bd >> 32) + static_cast<std::uint32_t>(ad) + static_cast<std::uint32_t>(bc);
884
885 return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
886 (intermediate << 32) + static_cast<std::uint32_t>(bd)};
887
888 #endif
889 }
890
891 612 BOOST_JSON_SAFEBUFFERS inline std::uint64_t umul128_upper64(std::uint64_t x, std::uint64_t y) noexcept
892 {
893 #if defined(BOOST_HAS_INT128)
894
895 612 auto result = static_cast<boost::uint128_type>(x) * static_cast<boost::uint128_type>(y);
896 612 return static_cast<std::uint64_t>(result >> 64);
897
898 #elif defined(BOOST_JSON_HAS_MSVC_64BIT_INTRINSICS)
899
900 return __umulh(x, y);
901
902 #else
903
904 auto a = static_cast<std::uint32_t>(x >> 32);
905 auto b = static_cast<std::uint32_t>(x);
906 auto c = static_cast<std::uint32_t>(y >> 32);
907 auto d = static_cast<std::uint32_t>(y);
908
909 auto ac = umul64(a, c);
910 auto bc = umul64(b, c);
911 auto ad = umul64(a, d);
912 auto bd = umul64(b, d);
913
914 auto intermediate = (bd >> 32) + static_cast<std::uint32_t>(ad) + static_cast<std::uint32_t>(bc);
915
916 return ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32);
917
918 #endif
919 }
920
921 // Get upper 128-bits of multiplication of a 64-bit unsigned integer and a 128-bit
922 // unsigned integer.
923 306 BOOST_JSON_SAFEBUFFERS inline uint128 umul192_upper128(std::uint64_t x, uint128 y) noexcept
924 {
925 306 auto r = umul128(x, y.high);
926 306 r += umul128_upper64(x, y.low);
927 306 return r;
928 }
929
930 // Get upper 64-bits of multiplication of a 32-bit unsigned integer and a 64-bit
931 // unsigned integer.
932 inline std::uint64_t umul96_upper64(std::uint32_t x, std::uint64_t y) noexcept
933 {
934 #if defined(BOOST_HAS_INT128) || defined(BOOST_JSON_HAS_MSVC_64BIT_INTRINSICS)
935
936 return umul128_upper64(static_cast<std::uint64_t>(x) << 32, y);
937
938 #else
939
940 auto yh = static_cast<std::uint32_t>(y >> 32);
941 auto yl = static_cast<std::uint32_t>(y);
942
943 auto xyh = umul64(x, yh);
944 auto xyl = umul64(x, yl);
945
946 return xyh + (xyl >> 32);
947
948 #endif
949 }
950
951 // Get lower 128-bits of multiplication of a 64-bit unsigned integer and a 128-bit
952 // unsigned integer.
953 ✗ BOOST_JSON_SAFEBUFFERS inline uint128 umul192_lower128(std::uint64_t x, uint128 y) noexcept
954 {
955 ✗ auto high = x * y.high;
956 ✗ auto highlow = umul128(x, y.low);
957 ✗ return {high + highlow.high, highlow.low};
958 }
959
960 // Get lower 64-bits of multiplication of a 32-bit unsigned integer and a 64-bit
961 // unsigned integer.
962 inline std::uint64_t umul96_lower64(std::uint32_t x, std::uint64_t y) noexcept
963 {
964 return x * y;
965 }
966
967 } // namespace detail
968 } // namespace json
969 } // namespace boost
970
971 // Non-standard libraries may add specializations for library-provided types
972 namespace std {
973
974 template <>
975 struct numeric_limits<boost::json::detail::uint128>
976 {
977 // Member constants
978 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_specialized = true;
979 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_signed = false;
980 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_integer = true;
981 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_exact = true;
982 BOOST_ATTRIBUTE_UNUSED static constexpr bool has_infinity = false;
983 BOOST_ATTRIBUTE_UNUSED static constexpr bool has_quiet_NaN = false;
984 BOOST_ATTRIBUTE_UNUSED static constexpr bool has_signaling_NaN = false;
985 BOOST_ATTRIBUTE_UNUSED static constexpr std::float_round_style round_style = std::round_toward_zero;
986 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_iec559 = false;
987 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_bounded = true;
988 BOOST_ATTRIBUTE_UNUSED static constexpr bool is_modulo = true;
989 BOOST_ATTRIBUTE_UNUSED static constexpr int digits = 128;
990 BOOST_ATTRIBUTE_UNUSED static constexpr int digits10 = 38;
991 BOOST_ATTRIBUTE_UNUSED static constexpr int max_digits10 = 0;
992 BOOST_ATTRIBUTE_UNUSED static constexpr int radix = 2;
993 BOOST_ATTRIBUTE_UNUSED static constexpr int min_exponent = 0;
994 BOOST_ATTRIBUTE_UNUSED static constexpr int min_exponent10 = 0;
995 BOOST_ATTRIBUTE_UNUSED static constexpr int max_exponent = 0;
996 BOOST_ATTRIBUTE_UNUSED static constexpr int max_exponent10 = 0;
997 BOOST_ATTRIBUTE_UNUSED static constexpr bool traps = std::numeric_limits<std::uint64_t>::traps;
998 BOOST_ATTRIBUTE_UNUSED static constexpr bool tinyness_before = false;
999
1000 // Member functions
1001 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 (min)() { return 0; }
1002 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 lowest() { return 0; }
1003 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 (max)() { return {UINT64_MAX, UINT64_MAX}; }
1004 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 epsilon() { return 0; }
1005 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 round_error() { return 0; }
1006 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 infinity() { return 0; }
1007 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 quiet_NaN() { return 0; }
1008 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 signaling_NaN() { return 0; }
1009 BOOST_ATTRIBUTE_UNUSED static constexpr boost::json::detail::uint128 (denorm_min)() { return 0; }
1010 };
1011
1012 } // Namespace std
1013
1014 #endif // BOOST_JSON_DETAIL_DRAGONBOX_EMULATED128_HPP
1015