Line data 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 "ient, 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 0 : BOOST_JSON_SAFEBUFFERS inline uint128 umul192_lower128(std::uint64_t x, uint128 y) noexcept
954 : {
955 0 : auto high = x * y.high;
956 0 : auto highlow = umul128(x, y.low);
957 0 : 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
|
