AsmJit
Low-Latency Machine Code Generation
asmjit::Support Namespace Reference [¶]
Contains support classes and functions that may be used by AsmJit source and header files.
Anything defined here is considered internal and should not be used outside of AsmJit and related projects like AsmTK.
Classes
struct Array
class ArrayReverseIterator
class BitVectorIterator
class BitVectorOpIterator
class BitWordIterator
struct Compare
struct ConstCTZ
struct EnumValues
struct Temporary
Enumerations
enum class SortOrder : uint32_t
Functions
template<typename T>
template<typename T>
template<typename T>
template<typename T>
static constexpr Internal::StdInt<sizeof(T), std::is_unsigned_v<T> >::Type asStdInt(const T& x) noexcept
static Dst* offsetPtr(Src* ptr, const Offset& n) noexcept
static const Dst* offsetPtr(const Src* ptr, const Offset& n) noexcept
static constexpr bool bool_and(Args&&... args) noexcept
static constexpr bool bool_or(Args&&... args) noexcept
template<typename Dst, typename Src>
static constexpr uint32_t bitSizeOf() noexcept
template<typename T>
static constexpr T allOnes() noexcept
template<typename X, typename Y>
template<typename X, typename Y>
template<typename X, typename Y>
static constexpr X ror(const X& x, const Y& y) noexcept
template<typename X, typename Y>
template<typename T>
template<typename T, typename IndexT>
static constexpr bool isLsbMask(const T& value) noexcept
static constexpr bool isConsecutiveMask(const T& value) noexcept
template<typename T, typename CountT>
template<typename T, typename CountT>
template<typename Index>
template<typename Index, typename... Args>
template<typename DstT, typename SrcT>
template<typename A, typename B>
static constexpr T fillTrailingBits(const T& x) noexcept
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
static constexpr T min(const T& a, const T& b) noexcept
static constexpr T min(const T& a, const T& b, Args&&... args) noexcept
static constexpr T max(const T& a, const T& b) noexcept
static constexpr T max(const T& a, const T& b, Args&&... args) noexcept
static int64_t immediateFromT(const T& x) noexcept
static T immediateToT(int64_t x) noexcept
static T addOverflow(const T& x, const T& y, FastUInt8* of) noexcept
static T subOverflow(const T& x, const T& y, FastUInt8* of) noexcept
static T mulOverflow(const T& x, const T& y, FastUInt8* of) noexcept
static T maddOverflow(const T& x, const T& y, const T& addend, FastUInt8* of) noexcept
template<typename T>
template<typename T, typename N>
template<typename T>
template<typename T, typename N>
static constexpr bool isAligned(X base, Y alignment) noexcept
static constexpr X alignUp(X x, Y alignment) noexcept
static constexpr T alignUpPowerOf2(T x) noexcept
template<typename X, typename Y>
static constexpr X alignDown(X x, Y alignment) noexcept
template<typename X, typename Y>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
static T byteswap(T x) noexcept
static constexpr uint32_t unpackU32At0(T x) noexcept
static constexpr uint32_t unpackU32At1(T x) noexcept
static constexpr T asciiToLower(T c) noexcept
static constexpr T asciiToUpper(T c) noexcept
static int compareStringViews(const char* aData, size_t aSize, const char* bData, size_t bSize) noexcept
static T loada(const void* p) noexcept
static T loadu(const void* p) noexcept
template<ByteOrder BO, typename T>
static T loada(const void* p) noexcept
template<ByteOrder BO, typename T>
static T loadu(const void* p) noexcept
static void storea(void* p, T x) noexcept
static void storeu(void* p, T x) noexcept
template<ByteOrder BO, typename T>
static void storea(void* p, T x) noexcept
template<ByteOrder BO, typename T>
static void storeu(void* p, T x) noexcept
template<typename T>
template<typename T>
template<typename T>
template<typename T>
template<typename T>
static size_t bitVectorIndexOf(T* buf, size_t start, bool value) noexcept
template<typename T, typename CompareT = Compare<SortOrder::kAscending>>
template<typename T, class CompareT = Compare<SortOrder::kAscending>>
using Support::BitWord = typedef Internal::StdInt<sizeof(uintptr_t), 1>::Type[¶]
Storage used to store a pack of bits (should by compatible with a machine word).
class Support::SortOrder : uint32_tenumstrong[¶]
template<typename T>Internal::Int32Or64<T, 0>::Type Support::asInt(const T& x)constexprstaticnoexcept[¶]
Casts an integer x to either int32_t or int64_t depending on T.
template<typename T>Internal::Int32Or64<T, 1>::Type Support::asUInt(const T& x)constexprstaticnoexcept[¶]
Casts an integer x to either uint32_t or uint64_t depending on T.
template<typename T>Internal::Int32Or64<T>::Type Support::asNormalized(const T& x)constexprstaticnoexcept[¶]
Casts an integer x to either int32_t, uint32_t,int64_t, oruint64_tdepending onT`.
template<typename T>Internal::StdInt<sizeof(T), std::is_unsigned_v<T> >::Type Support::asStdInt(const T& x)constexprstaticnoexcept[¶]
Casts an integer x to the same type as defined by <stdint.h>.
template<typename Dst, typename Src>Dst Support::bitCast(const Src& x)staticnoexcept[¶]
Bit-casts from Src type to Dst type.
Useful to bit-cast between integers and floating points.
template<typename T>T Support::neg(const T& x)constexprstaticnoexcept[¶]
Returns 0 - x in a safe way (no undefined behavior), works for unsigned numbers as well.
template<typename X, typename Y>X Support::shl(const X& x, const Y& y)constexprstaticnoexcept[¶]
Returns x << y (shift left logical) by explicitly casting x to an unsigned type and back.
template<typename X, typename Y>X Support::shr(const X& x, const Y& y)constexprstaticnoexcept[¶]
Returns x >> y (shift right logical) by explicitly casting x to an unsigned type and back.
template<typename X, typename Y>X Support::sar(const X& x, const Y& y)constexprstaticnoexcept[¶]
Returns x >> y (shift right arithmetic) by explicitly casting x to a signed type and back.
template<typename X, typename Y>X Support::or_shr(const X& x, const Y& y)constexprstaticnoexcept[¶]
Returns x | (x >> y) - helper used by some bit manipulation helpers.
template<typename T>T Support::blsi(T x)constexprstaticnoexcept[¶]
Returns x & -x - extracts lowest set isolated bit (like BLSI instruction).
template<typename T, typename IndexT>bool Support::bitTest(T x, IndexT n)constexprstaticnoexcept[¶]
Tests whether the given value x has nth bit set.
template<typename T, typename CountT>T Support::lsbMask(const CountT& n)constexprstaticnoexcept[¶]
Generates a trailing bit-mask that has n least significant (trailing) bits set.
template<typename T, typename CountT>T Support::msbMask(const CountT& n)constexprstaticnoexcept[¶]
Generates a leading bit-mask that has n most significant (leading) bits set.
template<typename Index>uint32_t Support::bitMask(const Index& x)constexprstaticnoexcept[1/2][¶]
Returns a bit-mask that has x bit set.
template<typename Index, typename... Args>uint32_t Support::bitMask(const Index& x, Args... args)constexprstaticnoexcept[2/2][¶]
Returns a bit-mask that has x bit set (multiple arguments).
template<typename DstT, typename SrcT>DstT Support::bitMaskFromBool(SrcT b)constexprstaticnoexcept[¶]
Converts a boolean value b to zero or full mask (all bits set).
template<typename A, typename B>bool Support::test(A a, B b)constexprstaticnoexcept[¶]
Tests whether a & b is non-zero.
template<typename T>uint32_t Support::clz(T x)staticnoexcept[¶]
Count leading zeros in x (returns a position of a first bit set in x).
- Note
- The input MUST NOT be zero, otherwise the result is undefined.
template<typename T>uint32_t Support::ctz(T x)staticnoexcept[¶]
Count trailing zeros in x (returns a position of a first bit set in x).
- Note
- The input MUST NOT be zero, otherwise the result is undefined.
template<typename T>uint32_t Support::popcnt(T x)staticnoexcept[¶]
Calculates count of bits in x.
template<typename T>uint32_t Support::constPopcnt(T x)staticnoexcept[¶]
Calculates count of bits in x (useful in constant expressions).
template<typename T>bool Support::hasAtLeast2BitsSet(T x)constexprstaticnoexcept[¶]
Tests whether x has at least 2 bits set.
template<typename T>bool Support::isPowerOf2(T x)constexprstaticnoexcept[¶]
Tests whether x is a power of two (only one bit is set).
template<typename T, typename N>bool Support::isPowerOf2UpTo(T x, N n)constexprstaticnoexcept[¶]
Tests whether x is a power of two up to n.
template<typename T>bool Support::isZeroOrPowerOf2(T x)constexprstaticnoexcept[¶]
Tests whether x is either zero or a power of two (only one bit is set).
template<typename T, typename N>bool Support::isZeroOrPowerOf2UpTo(T x, N n)constexprstaticnoexcept[¶]
Tests whether x is either zero or a power of two up to n.
template<typename X, typename Y>Internal::StdInt<sizeof(X), 1>::Type Support::alignUpDiff(X base, Y alignment)constexprstaticnoexcept[¶]
Returns either zero or a positive difference between base and base when aligned to alignment.
template<typename X, typename Y>X Support::numGranularized(X base, Y granularity)constexprstaticnoexcept[¶]
Calculates the number of elements that would be required if base is granularized by granularity.
This function can be used to calculate the number of BitWords to represent N bits, for example.
template<typename T>bool Support::isBetween(const T& x, const T& a, const T& b)constexprstaticnoexcept[¶]
Checks whether x is greater than or equal to a and lesser than or equal to b.
template<typename T>bool Support::isInt4(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 4-bit signed integer.
template<typename T>bool Support::isInt7(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 7-bit signed integer.
template<typename T>bool Support::isInt8(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to an 8-bit signed integer.
template<typename T>bool Support::isInt9(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 9-bit signed integer.
template<typename T>bool Support::isInt10(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 10-bit signed integer.
template<typename T>bool Support::isInt16(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 16-bit signed integer.
template<typename T>bool Support::isInt32(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 32-bit signed integer.
template<typename T>bool Support::isUInt4(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 4-bit unsigned integer.
template<typename T>bool Support::isUInt8(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to an 8-bit unsigned integer.
template<typename T>bool Support::isUInt12(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 12-bit unsigned integer (ARM specific).
template<typename T>bool Support::isUInt16(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 16-bit unsigned integer.
template<typename T>bool Support::isUInt32(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 32-bit unsigned integer.
template<typename T>bool Support::isIntOrUInt32(T x)constexprstaticnoexcept[¶]
Checks whether the given integer x can be casted to a 32-bit unsigned integer.
uint32_t Support::bytepack32_4x8(uint32_t a, uint32_t b, uint32_t c, uint32_t d)constexprstaticnoexcept[¶]
Pack four 8-bit integer into a 32-bit integer as it is an array of {b0,b1,b2,b3}.
int Support::compareStringViews(const char* aData, size_t aSize, const char* bData, size_t bSize)staticnoexcept[¶]
Compares two string views.
template<typename T>bool Support::bitVectorGetBit(T* buf, size_t index)staticnoexcept[¶]
Sets bit in a bit-vector buf at index.
template<typename T>void Support::bitVectorSetBit(T* buf, size_t index, bool value)staticnoexcept[¶]
Sets bit in a bit-vector buf at index to value.
template<typename T>void Support::bitVectorFlipBit(T* buf, size_t index)staticnoexcept[¶]
Sets bit in a bit-vector buf at index to value.
template<typename T>void Support::bitVectorFill(T* buf, size_t index, size_t count)staticnoexcept[¶]
Fills count bits in bit-vector buf starting at bit-index index.
template<typename T>void Support::bitVectorClear(T* buf, size_t index, size_t count)staticnoexcept[¶]
Clears count bits in bit-vector buf starting at bit-index index.
template<typename T, typename CompareT = Compare<SortOrder::kAscending>>void Support::iSort(T* base, size_t size, const CompareT& cmp = CompareT())staticnoexcept[¶]
Insertion sort.
template<typename T, class CompareT = Compare<SortOrder::kAscending>>void Support::qSort(T* base, size_t size, const CompareT& cmp = CompareT())staticnoexcept[¶]
Quick sort implementation.
The main reason to provide a custom qsort implementation is that we needed something that will never throw bad_alloc exception. This implementation doesn't use dynamic memory allocation.