13#ifndef LLVM_SUPPORT_MATHEXTRAS_H
14#define LLVM_SUPPORT_MATHEXTRAS_H
31constexpr double e = 2.7182818284590452354,
33 ln2 = .69314718055994530942,
34 ln10 = 2.3025850929940456840,
37 pi = 3.1415926535897932385,
45 phi = 1.6180339887498948482;
46constexpr float ef = 2.71828183F,
66 static_assert(std::is_unsigned_v<T>,
"Invalid type!");
67 const unsigned Bits = CHAR_BIT *
sizeof(
T);
68 assert(
N <= Bits &&
"Invalid bit index");
71 return T(-1) >> (Bits -
N);
77 return ~maskTrailingOnes<T>(CHAR_BIT *
sizeof(
T) -
N);
83 return maskLeadingOnes<T>(CHAR_BIT *
sizeof(
T) -
N);
89 return maskTrailingOnes<T>(CHAR_BIT *
sizeof(
T) -
N);
96#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
97#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
98#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
107#if __has_builtin(__builtin_bitreverse8)
108 if constexpr (std::is_same_v<T, uint8_t>)
109 return __builtin_bitreverse8(Val);
111#if __has_builtin(__builtin_bitreverse16)
112 if constexpr (std::is_same_v<T, uint16_t>)
113 return __builtin_bitreverse16(Val);
115#if __has_builtin(__builtin_bitreverse32)
116 if constexpr (std::is_same_v<T, uint32_t>)
117 return __builtin_bitreverse32(Val);
119#if __has_builtin(__builtin_bitreverse64)
120 if constexpr (std::is_same_v<T, uint64_t>)
121 return __builtin_bitreverse64(Val);
124 unsigned char in[
sizeof(Val)];
125 unsigned char out[
sizeof(Val)];
126 std::memcpy(in, &Val,
sizeof(Val));
127 for (
unsigned i = 0; i <
sizeof(Val); ++i)
129 std::memcpy(&Val, out,
sizeof(Val));
153template <
unsigned N>
constexpr inline bool isInt(int64_t x) {
154 if constexpr (
N == 0)
156 if constexpr (
N == 8)
157 return static_cast<int8_t
>(x) == x;
158 if constexpr (
N == 16)
159 return static_cast<int16_t
>(x) == x;
160 if constexpr (
N == 32)
161 return static_cast<int32_t
>(x) == x;
162 if constexpr (
N < 64)
163 return -(INT64_C(1) << (
N - 1)) <= x && x < (INT64_C(1) << (
N - 1));
169template <
unsigned N,
unsigned S>
171 static_assert(S < 64,
"isShiftedInt<N, S> with S >= 64 is too much.");
172 static_assert(
N + S <= 64,
"isShiftedInt<N, S> with N + S > 64 is too wide.");
173 return isInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
178 if constexpr (
N == 0)
180 if constexpr (
N == 8)
181 return static_cast<uint8_t
>(x) == x;
182 if constexpr (
N == 16)
183 return static_cast<uint16_t>(x) == x;
184 if constexpr (
N == 32)
185 return static_cast<uint32_t>(x) == x;
186 if constexpr (
N < 64)
187 return x < (UINT64_C(1) << (
N));
193template <
unsigned N,
unsigned S>
195 static_assert(S < 64,
"isShiftedUInt<N, S> with S >= 64 is too much.");
196 static_assert(
N + S <= 64,
197 "isShiftedUInt<N, S> with N + S > 64 is too wide.");
199 return isUInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
204 assert(
N <= 64 &&
"integer width out of range");
220 assert(
N <= 64 &&
"integer width out of range");
224 return UINT64_C(1) + ~(UINT64_C(1) << (
N - 1));
229 assert(
N <= 64 &&
"integer width out of range");
235 return (UINT64_C(1) << (
N - 1)) - 1;
313template <
size_t kValue>
constexpr inline size_t CTLog2() {
315 "Value is not a valid power of 2");
316 return 1 +
CTLog2<kValue / 2>();
319template <>
constexpr inline size_t CTLog2<1>() {
return 0; }
355 return (
A |
B) & (1 + ~(
A |
B));
395 "Align must be a power of 2");
423 static_assert(
Align != 0u,
"Align must be non-zero");
429 return alignTo(Numerator, Denominator) / Denominator;
434 return (Numerator + (Denominator / 2)) / Denominator;
448 static_assert(
B <= 32,
"Bit width out of range.");
449 if constexpr (
B == 0)
451 return int32_t(
X << (32 -
B)) >> (32 -
B);
457 assert(
B <= 32 &&
"Bit width out of range.");
460 return int32_t(
X << (32 -
B)) >> (32 -
B);
466 static_assert(
B <= 64,
"Bit width out of range.");
467 if constexpr (
B == 0)
469 return int64_t(x << (64 -
B)) >> (64 -
B);
475 assert(
B <= 64 &&
"Bit width out of range.");
478 return int64_t(
X << (64 -
B)) >> (64 -
B);
485 return X >
Y ? (
X -
Y) : (
Y -
X);
492std::enable_if_t<std::is_unsigned_v<T>,
T>
495 bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
498 Overflowed = (Z <
X || Z <
Y);
500 return std::numeric_limits<T>::max();
507template <
class T,
class... Ts>
510 bool Overflowed =
false;
513 return SaturatingAdd(std::numeric_limits<T>::max(),
T(1), Args...);
521std::enable_if_t<std::is_unsigned_v<T>,
T>
524 bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
537 const T Max = std::numeric_limits<T>::max();
539 if (Log2Z < Log2Max) {
542 if (Log2Z > Log2Max) {
551 if (Z & ~(Max >> 1)) {
567std::enable_if_t<std::is_unsigned_v<T>,
T>
570 bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
586#if __has_builtin(__builtin_add_overflow)
587 return __builtin_add_overflow(
X,
Y, &Result);
590 using U = std::make_unsigned_t<T>;
591 const U UX =
static_cast<U
>(
X);
592 const U UY =
static_cast<U
>(
Y);
593 const U UResult = UX + UY;
596 Result =
static_cast<T>(UResult);
612#if __has_builtin(__builtin_sub_overflow)
613 return __builtin_sub_overflow(
X,
Y, &Result);
616 using U = std::make_unsigned_t<T>;
617 const U UX =
static_cast<U
>(
X);
618 const U UY =
static_cast<U
>(
Y);
619 const U UResult = UX - UY;
622 Result =
static_cast<T>(UResult);
639 using U = std::make_unsigned_t<T>;
640 const U UX =
X < 0 ? (0 -
static_cast<U
>(
X)) :
static_cast<U
>(
X);
641 const U UY =
Y < 0 ? (0 -
static_cast<U
>(
Y)) :
static_cast<U
>(
Y);
642 const U UResult = UX * UY;
645 const bool IsNegative = (
X < 0) ^ (
Y < 0);
646 Result = IsNegative ? (0 - UResult) : UResult;
649 if (UX == 0 || UY == 0)
656 return UX > (
static_cast<U
>(std::numeric_limits<T>::max()) + U(1)) / UY;
658 return UX > (
static_cast<U
>(std::numeric_limits<T>::max())) / UY;
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements the C++20 <bit> header.
LLVM Value Representation.
constexpr float inv_sqrtpif
constexpr double inv_sqrt2
constexpr double inv_sqrt3
constexpr double inv_sqrtpi
constexpr float inv_sqrt2f
constexpr float inv_sqrt3f
This is an optimization pass for GlobalISel generic memory operations.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
std::enable_if_t< std::is_signed_v< T >, T > MulOverflow(T X, T Y, T &Result)
Multiply two signed integers, computing the two's complement truncated result, returning true if an o...
int64_t maxIntN(int64_t N)
Gets the maximum value for a N-bit signed integer.
uint64_t alignToPowerOf2(uint64_t Value, uint64_t Align)
int popcount(T Value) noexcept
Count the number of set bits in a value.
constexpr size_t CTLog2()
Compile time Log2.
uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator)
Returns the integer ceil(Numerator / Denominator).
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
constexpr size_t CTLog2< 1 >()
unsigned Log2_64_Ceil(uint64_t Value)
Return the ceil log base 2 of the specified value, 64 if the value is zero.
constexpr bool isMask_32(uint32_t Value)
Return true if the argument is a non-empty sequence of ones starting at the least significant bit wit...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
constexpr bool isShiftedMask_32(uint32_t Value)
Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit ver...
unsigned Log2_64(uint64_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
constexpr bool isShiftedMask_64(uint64_t Value)
Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit ver...
std::enable_if_t< std::is_unsigned_v< T >, T > AbsoluteDifference(T X, T Y)
Subtract two unsigned integers, X and Y, of type T and return the absolute value of the result.
constexpr bool has_single_bit(T Value) noexcept
uint64_t divideNearest(uint64_t Numerator, uint64_t Denominator)
Returns the integer nearest(Numerator / Denominator).
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
int countl_zero(T Val)
Count number of 0's from the most significant bit to the least stopping at the first 1.
T maskLeadingZeros(unsigned N)
Create a bitmask with the N left-most bits set to 0, and all other bits set to 1.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
T maskTrailingOnes(unsigned N)
Create a bitmask with the N right-most bits set to 1, and all other bits set to 0.
T maskTrailingZeros(unsigned N)
Create a bitmask with the N right-most bits set to 0, and all other bits set to 1.
constexpr uint32_t Hi_32(uint64_t Value)
Return the high 32 bits of a 64 bit value.
constexpr bool isMask_64(uint64_t Value)
Return true if the argument is a non-empty sequence of ones starting at the least significant bit wit...
std::enable_if_t< std::is_unsigned_v< T >, T > SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed=nullptr)
Multiply two unsigned integers, X and Y, and add the unsigned integer, A to the product.
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
constexpr uint32_t Lo_32(uint64_t Value)
Return the low 32 bits of a 64 bit value.
const float huge_valf
Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
std::enable_if_t< std::is_unsigned_v< T >, T > SaturatingMultiply(T X, T Y, bool *ResultOverflowed=nullptr)
Multiply two unsigned integers, X and Y, of type T.
bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
int64_t minIntN(int64_t N)
Gets the minimum value for a N-bit signed integer.
constexpr bool isShiftedInt(int64_t x)
Checks if a signed integer is an N bit number shifted left by S.
constexpr int32_t SignExtend32(uint32_t X)
Sign-extend the number in the bottom B bits of X to a 32-bit integer.
T maskLeadingOnes(unsigned N)
Create a bitmask with the N left-most bits set to 1, and all other bits set to 0.
constexpr int64_t SignExtend64(uint64_t x)
Sign-extend the number in the bottom B bits of X to a 64-bit integer.
std::enable_if_t< std::is_signed_v< T >, T > AddOverflow(T X, T Y, T &Result)
Add two signed integers, computing the two's complement truncated result, returning true if overflow ...
uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the largest uint64_t less than or equal to Value and is Skew mod Align.
std::enable_if_t< std::is_signed_v< T >, T > SubOverflow(T X, T Y, T &Result)
Subtract two signed integers, computing the two's complement truncated result, returning true if an o...
static const unsigned char BitReverseTable256[256]
Macro compressed bit reversal table for 256 bits.
T reverseBits(T Val)
Reverse the bits in Val.
std::enable_if_t< std::is_unsigned_v< T >, T > SaturatingAdd(T X, T Y, bool *ResultOverflowed=nullptr)
Add two unsigned integers, X and Y, of type T.
constexpr bool isShiftedUInt(uint64_t x)
Checks if a unsigned integer is an N bit number shifted left by S.
constexpr uint64_t Make_64(uint32_t High, uint32_t Low)
Make a 64-bit integer from a high / low pair of 32-bit integers.
uint64_t maxUIntN(uint64_t N)
Gets the maximum value for a N-bit unsigned integer.
constexpr uint64_t NextPowerOf2(uint64_t A)
Returns the next power of two (in 64-bits) that is strictly greater than A.
This struct is a compact representation of a valid (non-zero power of two) alignment.