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
static constexpr bool isUnsigned() noexcept
template<typename T>
template<typename T>
template<typename T>
template<typename T>
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)
static constexpr bool isConsecutiveMask(const T& value)
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>
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 constexpr bool isAligned(X base, Y alignment) noexcept
template<typename T>
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 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
template<ByteOrder BO, size_t Alignment>
static uint16_t readU16x(const void* p) noexcept
static uint16_t readU16u(const void* p) noexcept
static uint16_t readU16uLE(const void* p) noexcept
static uint16_t readU16uBE(const void* p) noexcept
template<ByteOrder BO, size_t Alignment>
static int16_t readI16x(const void* p) noexcept
static int16_t readI16u(const void* p) noexcept
static int16_t readI16uLE(const void* p) noexcept
static int16_t readI16uBE(const void* p) noexcept
template<ByteOrder BO = ByteOrder::kNative>
static uint32_t readU24u(const void* p) noexcept
template<ByteOrder BO, size_t Alignment>
static uint32_t readU32x(const void* p) noexcept
static uint32_t readU32u(const void* p) noexcept
static uint32_t readU32uLE(const void* p) noexcept
static uint32_t readU32uBE(const void* p) noexcept
template<ByteOrder BO, size_t Alignment>
static uint32_t readI32x(const void* p) noexcept
static int32_t readI32u(const void* p) noexcept
static int32_t readI32uLE(const void* p) noexcept
static int32_t readI32uBE(const void* p) noexcept
template<ByteOrder BO, size_t Alignment>
static uint64_t readU64x(const void* p) noexcept
static uint64_t readU64u(const void* p) noexcept
static uint64_t readU64uLE(const void* p) noexcept
static uint64_t readU64uBE(const void* p) noexcept
template<ByteOrder BO, size_t Alignment>
static int64_t readI64x(const void* p) noexcept
static int64_t readI64u(const void* p) noexcept
static int64_t readI64uLE(const void* p) noexcept
static int64_t readI64uBE(const void* p) noexcept
template<ByteOrder BO = ByteOrder::kNative, size_t Alignment = 1>
static void writeU16x(void* p, uint16_t x) noexcept
static void writeU16uLE(void* p, uint16_t x) noexcept
static void writeU16uBE(void* p, uint16_t x) noexcept
template<ByteOrder BO = ByteOrder::kNative, size_t Alignment = 1>
static void writeI16x(void* p, int16_t x) noexcept
static void writeI16uLE(void* p, int16_t x) noexcept
static void writeI16uBE(void* p, int16_t x) noexcept
template<ByteOrder BO = ByteOrder::kNative>
static void writeU24u(void* p, uint32_t v) noexcept
template<ByteOrder BO = ByteOrder::kNative, size_t Alignment = 1>
static void writeU32x(void* p, uint32_t x) noexcept
static void writeU32u(void* p, uint32_t x) noexcept
static void writeU32uLE(void* p, uint32_t x) noexcept
static void writeU32uBE(void* p, uint32_t x) noexcept
template<ByteOrder BO = ByteOrder::kNative, size_t Alignment = 1>
static void writeI32x(void* p, int32_t x) noexcept
static void writeI32u(void* p, int32_t x) noexcept
static void writeI32uLE(void* p, int32_t x) noexcept
static void writeI32uBE(void* p, int32_t x) noexcept
template<ByteOrder BO = ByteOrder::kNative, size_t Alignment = 1>
static void writeU64x(void* p, uint64_t x) noexcept
static void writeU64u(void* p, uint64_t x) noexcept
static void writeU64uLE(void* p, uint64_t x) noexcept
static void writeU64uBE(void* p, uint64_t x) noexcept
template<ByteOrder BO = ByteOrder::kNative, size_t Alignment = 1>
static void writeI64x(void* p, int64_t x) noexcept
static void writeI64u(void* p, int64_t x) noexcept
static void writeI64uLE(void* p, int64_t x) noexcept
static void writeI64uBE(void* p, int64_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>>
typedef Internal::StdInt<sizeof(uintptr_t), 1>::Type Support::BitWord[¶]
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), isUnsigned<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::isPowerOf2(T x)constexprstaticnoexcept[¶]
Tests whether the x is a power of two (only one bit is set).
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.