LLVM 19.0.0git
Namespaces | Macros | Functions | Variables
MathExtras.h File Reference
#include "llvm/ADT/bit.h"
#include "llvm/Support/Compiler.h"
#include <cassert>
#include <climits>
#include <cstdint>
#include <cstring>
#include <limits>
#include <type_traits>

Go to the source code of this file.

Namespaces

namespace  llvm
 This is an optimization pass for GlobalISel generic memory operations.
 
namespace  llvm::numbers
 Mathematical constants.
 

Macros

#define R2(n)   n, n + 2 * 64, n + 1 * 64, n + 3 * 64
 
#define R4(n)   R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
 
#define R6(n)   R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
 

Functions

template<typename T >
T llvm::maskTrailingOnes (unsigned N)
 Create a bitmask with the N right-most bits set to 1, and all other bits set to 0.
 
template<typename T >
T llvm::maskLeadingOnes (unsigned N)
 Create a bitmask with the N left-most bits set to 1, and all other bits set to 0.
 
template<typename T >
T llvm::maskTrailingZeros (unsigned N)
 Create a bitmask with the N right-most bits set to 0, and all other bits set to 1.
 
template<typename T >
T llvm::maskLeadingZeros (unsigned N)
 Create a bitmask with the N left-most bits set to 0, and all other bits set to 1.
 
template<typename T >
T llvm::reverseBits (T Val)
 Reverse the bits in Val.
 
constexpr uint32_t llvm::Hi_32 (uint64_t Value)
 Return the high 32 bits of a 64 bit value.
 
constexpr uint32_t llvm::Lo_32 (uint64_t Value)
 Return the low 32 bits of a 64 bit value.
 
constexpr uint64_t llvm::Make_64 (uint32_t High, uint32_t Low)
 Make a 64-bit integer from a high / low pair of 32-bit integers.
 
template<unsigned N>
constexpr bool llvm::isInt (int64_t x)
 Checks if an integer fits into the given bit width.
 
template<unsigned N, unsigned S>
constexpr bool llvm::isShiftedInt (int64_t x)
 Checks if a signed integer is an N bit number shifted left by S.
 
template<unsigned N>
constexpr bool llvm::isUInt (uint64_t x)
 Checks if an unsigned integer fits into the given bit width.
 
template<unsigned N, unsigned S>
constexpr bool llvm::isShiftedUInt (uint64_t x)
 Checks if a unsigned integer is an N bit number shifted left by S.
 
uint64_t llvm::maxUIntN (uint64_t N)
 Gets the maximum value for a N-bit unsigned integer.
 
int64_t llvm::minIntN (int64_t N)
 Gets the minimum value for a N-bit signed integer.
 
int64_t llvm::maxIntN (int64_t N)
 Gets the maximum value for a N-bit signed integer.
 
bool llvm::isUIntN (unsigned N, uint64_t x)
 Checks if an unsigned integer fits into the given (dynamic) bit width.
 
bool llvm::isIntN (unsigned N, int64_t x)
 Checks if an signed integer fits into the given (dynamic) bit width.
 
constexpr bool llvm::isMask_32 (uint32_t Value)
 Return true if the argument is a non-empty sequence of ones starting at the least significant bit with the remainder zero (32 bit version).
 
constexpr bool llvm::isMask_64 (uint64_t Value)
 Return true if the argument is a non-empty sequence of ones starting at the least significant bit with the remainder zero (64 bit version).
 
constexpr bool llvm::isShiftedMask_32 (uint32_t Value)
 Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit version.) Ex.
 
constexpr bool llvm::isShiftedMask_64 (uint64_t Value)
 Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit version.)
 
constexpr bool llvm::isPowerOf2_32 (uint32_t Value)
 Return true if the argument is a power of two > 0.
 
constexpr bool llvm::isPowerOf2_64 (uint64_t Value)
 Return true if the argument is a power of two > 0 (64 bit edition.)
 
bool llvm::isShiftedMask_32 (uint32_t Value, unsigned &MaskIdx, unsigned &MaskLen)
 Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit version.) Ex.
 
bool llvm::isShiftedMask_64 (uint64_t Value, unsigned &MaskIdx, unsigned &MaskLen)
 Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit version.) If true, MaskIdx will specify the index of the lowest set bit and MaskLen is updated to specify the length of the mask, else neither are updated.
 
template<size_t kValue>
constexpr size_t llvm::CTLog2 ()
 Compile time Log2.
 
template<>
constexpr size_t llvm::CTLog2< 1 > ()
 
unsigned llvm::Log2_32 (uint32_t Value)
 Return the floor log base 2 of the specified value, -1 if the value is zero.
 
unsigned llvm::Log2_64 (uint64_t Value)
 Return the floor log base 2 of the specified value, -1 if the value is zero.
 
unsigned llvm::Log2_32_Ceil (uint32_t Value)
 Return the ceil log base 2 of the specified value, 32 if the value is zero.
 
unsigned llvm::Log2_64_Ceil (uint64_t Value)
 Return the ceil log base 2 of the specified value, 64 if the value is zero.
 
constexpr uint64_t llvm::MinAlign (uint64_t A, uint64_t B)
 A and B are either alignments or offsets.
 
constexpr uint64_t llvm::NextPowerOf2 (uint64_t A)
 Returns the next power of two (in 64-bits) that is strictly greater than A.
 
uint64_t llvm::PowerOf2Ceil (uint64_t A)
 Returns the power of two which is greater than or equal to the given value.
 
uint64_t llvm::alignTo (uint64_t Value, uint64_t Align)
 Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Align.
 
uint64_t llvm::alignToPowerOf2 (uint64_t Value, uint64_t Align)
 
uint64_t llvm::alignTo (uint64_t Value, uint64_t Align, uint64_t Skew)
 If non-zero Skew is specified, the return value will be a minimal integer that is greater than or equal to Size and equal to A * N + Skew for some integer N.
 
template<uint64_t Align>
constexpr uint64_t llvm::alignTo (uint64_t Value)
 Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Align.
 
uint64_t llvm::divideCeil (uint64_t Numerator, uint64_t Denominator)
 Returns the integer ceil(Numerator / Denominator).
 
uint64_t llvm::divideNearest (uint64_t Numerator, uint64_t Denominator)
 Returns the integer nearest(Numerator / Denominator).
 
uint64_t llvm::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.
 
template<unsigned B>
constexpr int32_t llvm::SignExtend32 (uint32_t X)
 Sign-extend the number in the bottom B bits of X to a 32-bit integer.
 
int32_t llvm::SignExtend32 (uint32_t X, unsigned B)
 Sign-extend the number in the bottom B bits of X to a 32-bit integer.
 
template<unsigned B>
constexpr int64_t llvm::SignExtend64 (uint64_t x)
 Sign-extend the number in the bottom B bits of X to a 64-bit integer.
 
int64_t llvm::SignExtend64 (uint64_t X, unsigned B)
 Sign-extend the number in the bottom B bits of X to a 64-bit integer.
 
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, Tllvm::AbsoluteDifference (T X, T Y)
 Subtract two unsigned integers, X and Y, of type T and return the absolute value of the result.
 
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, Tllvm::SaturatingAdd (T X, T Y, bool *ResultOverflowed=nullptr)
 Add two unsigned integers, X and Y, of type T.
 
template<class T , class... Ts>
std::enable_if_t< std::is_unsigned_v< T >, Tllvm::SaturatingAdd (T X, T Y, T Z, Ts... Args)
 Add multiple unsigned integers of type T.
 
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, Tllvm::SaturatingMultiply (T X, T Y, bool *ResultOverflowed=nullptr)
 Multiply two unsigned integers, X and Y, of type T.
 
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, Tllvm::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.
 
template<typename T >
std::enable_if_t< std::is_signed_v< T >, Tllvm::AddOverflow (T X, T Y, T &Result)
 Add two signed integers, computing the two's complement truncated result, returning true if overflow occurred.
 
template<typename T >
std::enable_if_t< std::is_signed_v< T >, Tllvm::SubOverflow (T X, T Y, T &Result)
 Subtract two signed integers, computing the two's complement truncated result, returning true if an overflow ocurred.
 
template<typename T >
std::enable_if_t< std::is_signed_v< T >, Tllvm::MulOverflow (T X, T Y, T &Result)
 Multiply two signed integers, computing the two's complement truncated result, returning true if an overflow ocurred.
 

Variables

constexpr double llvm::numbers::e = 2.7182818284590452354
 
constexpr double llvm::numbers::egamma = .57721566490153286061
 
constexpr double llvm::numbers::ln2 = .69314718055994530942
 
constexpr double llvm::numbers::ln10 = 2.3025850929940456840
 
constexpr double llvm::numbers::log2e = 1.4426950408889634074
 
constexpr double llvm::numbers::log10e = .43429448190325182765
 
constexpr double llvm::numbers::pi = 3.1415926535897932385
 
constexpr double llvm::numbers::inv_pi = .31830988618379067154
 
constexpr double llvm::numbers::sqrtpi = 1.7724538509055160273
 
constexpr double llvm::numbers::inv_sqrtpi = .56418958354775628695
 
constexpr double llvm::numbers::sqrt2 = 1.4142135623730950488
 
constexpr double llvm::numbers::inv_sqrt2 = .70710678118654752440
 
constexpr double llvm::numbers::sqrt3 = 1.7320508075688772935
 
constexpr double llvm::numbers::inv_sqrt3 = .57735026918962576451
 
constexpr double llvm::numbers::phi = 1.6180339887498948482
 
constexpr float llvm::numbers::ef = 2.71828183F
 
constexpr float llvm::numbers::egammaf = .577215665F
 
constexpr float llvm::numbers::ln2f = .693147181F
 
constexpr float llvm::numbers::ln10f = 2.30258509F
 
constexpr float llvm::numbers::log2ef = 1.44269504F
 
constexpr float llvm::numbers::log10ef = .434294482F
 
constexpr float llvm::numbers::pif = 3.14159265F
 
constexpr float llvm::numbers::inv_pif = .318309886F
 
constexpr float llvm::numbers::sqrtpif = 1.77245385F
 
constexpr float llvm::numbers::inv_sqrtpif = .564189584F
 
constexpr float llvm::numbers::sqrt2f = 1.41421356F
 
constexpr float llvm::numbers::inv_sqrt2f = .707106781F
 
constexpr float llvm::numbers::sqrt3f = 1.73205081F
 
constexpr float llvm::numbers::inv_sqrt3f = .577350269F
 
constexpr float llvm::numbers::phif = 1.61803399F
 
static const unsigned char llvm::BitReverseTable256 [256]
 Macro compressed bit reversal table for 256 bits.
 
const float llvm::huge_valf = HUGE_VALF
 Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
 

Macro Definition Documentation

◆ R2

#define R2 (   n)    n, n + 2 * 64, n + 1 * 64, n + 3 * 64

◆ R4

#define R4 (   n)    R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)

◆ R6

#define R6 (   n)    R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)