tuklib_integer.h File Reference

Various integer and bit operations. More...

#include "tuklib_common.h"
#include <string.h>

Go to the source code of this file.

Macros
#define	bswap16(n)
#define	bswap32(n)
#define	bswap64(n)
#define	conv16be(num)   bswap16(num)
#define	conv32be(num)   bswap32(num)
#define	conv64be(num)   bswap64(num)
#define	conv16le(num)   ((uint16_t)(num))
#define	conv32le(num)   ((uint32_t)(num))
#define	conv64le(num)   ((uint64_t)(num))
#define	write16le(buf, num)   write16ne(buf, conv16le(num))
#define	write32le(buf, num)   write32ne(buf, conv32le(num))
#define	tuklib_memcpy_aligned(dest, src, size)    memcpy(dest, src, size)
#define	TUKLIB_USE_UNSAFE_ALIGNED_READS   1
#define	aligned_write16be(buf, num)   aligned_write16ne((buf), conv16be(num))
#define	aligned_write16le(buf, num)   aligned_write16ne((buf), conv16le(num))
#define	aligned_write32be(buf, num)   aligned_write32ne((buf), conv32be(num))
#define	aligned_write32le(buf, num)   aligned_write32ne((buf), conv32le(num))
#define	aligned_write64be(buf, num)   aligned_write64ne((buf), conv64be(num))
#define	aligned_write64le(buf, num)   aligned_write64ne((buf), conv64le(num))
#define	bsf32   ctz32

Functions
static uint16_t	read16ne (const uint8_t *buf)
static uint32_t	read32ne (const uint8_t *buf)
static uint64_t	read64ne (const uint8_t *buf)
static void	write16ne (uint8_t *buf, uint16_t num)
static void	write32ne (uint8_t *buf, uint32_t num)
static void	write64ne (uint8_t *buf, uint64_t num)
static uint16_t	read16be (const uint8_t *buf)
static uint16_t	read16le (const uint8_t *buf)
static uint32_t	read32be (const uint8_t *buf)
static uint32_t	read32le (const uint8_t *buf)
static void	write16be (uint8_t *buf, uint16_t num)
static void	write32be (uint8_t *buf, uint32_t num)
static uint16_t	aligned_read16ne (const uint8_t *buf)
static uint32_t	aligned_read32ne (const uint8_t *buf)
static uint64_t	aligned_read64ne (const uint8_t *buf)
static void	aligned_write16ne (uint8_t *buf, uint16_t num)
static void	aligned_write32ne (uint8_t *buf, uint32_t num)
static void	aligned_write64ne (uint8_t *buf, uint64_t num)
static uint16_t	aligned_read16be (const uint8_t *buf)
static uint16_t	aligned_read16le (const uint8_t *buf)
static uint32_t	aligned_read32be (const uint8_t *buf)
static uint32_t	aligned_read32le (const uint8_t *buf)
static uint64_t	aligned_read64be (const uint8_t *buf)
static uint64_t	aligned_read64le (const uint8_t *buf)
static uint32_t	bsr32 (uint32_t n)
static uint32_t	clz32 (uint32_t n)
static uint32_t	ctz32 (uint32_t n)

Detailed Description

Various integer and bit operations.

This file provides macros or functions to do some basic integer and bit operations.

Native endian inline functions (XX = 16, 32, or 64):

• Unaligned native endian reads: readXXne(ptr)
• Unaligned native endian writes: writeXXne(ptr, num)
• Aligned native endian reads: aligned_readXXne(ptr)
• Aligned native endian writes: aligned_writeXXne(ptr, num)

Endianness-converting integer operations (these can be macros!) (XX = 16, 32, or 64; Y = b or l):

• Byte swapping: bswapXX(num)
• Byte order conversions to/from native (byteswaps if Y isn't the native endianness): convXXYe(num)
• Unaligned reads (16/32-bit only): readXXYe(ptr)
• Unaligned writes (16/32-bit only): writeXXYe(ptr, num)
• Aligned reads: aligned_readXXYe(ptr)
• Aligned writes: aligned_writeXXYe(ptr, num)

Since the above can macros, the arguments should have no side effects because they may be evaluated more than once.

Bit scan operations for non-zero 32-bit integers (inline functions):

• Bit scan reverse (find highest non-zero bit): bsr32(num)
• Count leading zeros: clz32(num)
• Count trailing zeros: ctz32(num)
• Bit scan forward (simply an alias for ctz32()): bsf32(num)

The above bit scan operations return 0-31. If num is zero, the result is undefined.

Definition in file tuklib_integer.h.

Macro Definition Documentation

aligned_write16be

#define aligned_write16be	(		buf,
			num
	)		aligned_write16ne((buf), conv16be(num))

Definition at line 572 of file tuklib_integer.h.

aligned_write16le

#define aligned_write16le	(		buf,
			num
	)		aligned_write16ne((buf), conv16le(num))

Definition at line 573 of file tuklib_integer.h.

aligned_write32be

#define aligned_write32be	(		buf,
			num
	)		aligned_write32ne((buf), conv32be(num))

Definition at line 574 of file tuklib_integer.h.

aligned_write32le

#define aligned_write32le	(		buf,
			num
	)		aligned_write32ne((buf), conv32le(num))

Definition at line 575 of file tuklib_integer.h.

aligned_write64be

#define aligned_write64be	(		buf,
			num
	)		aligned_write64ne((buf), conv64be(num))

Definition at line 576 of file tuklib_integer.h.

aligned_write64le

#define aligned_write64le	(		buf,
			num
	)		aligned_write64ne((buf), conv64le(num))

Definition at line 577 of file tuklib_integer.h.

bsf32

#define bsf32   ctz32

Definition at line 740 of file tuklib_integer.h.

bswap16

#define bswap16

(

n

)

Value:

          (uint16_t)( \
          (((n) & 0x00FFU) << 8) \
        | (((n) & 0xFF00U) >> 8) \
    )

Definition at line 118 of file tuklib_integer.h.

bswap32

#define bswap32

(

n

)

Value:

          (uint32_t)( \
          (((n) & UINT32_C(0x000000FF)) << 24) \
        | (((n) & UINT32_C(0x0000FF00)) << 8) \
        | (((n) & UINT32_C(0x00FF0000)) >> 8) \
        | (((n) & UINT32_C(0xFF000000)) >> 24) \
    )

Definition at line 125 of file tuklib_integer.h.

bswap64

#define bswap64

(

n

)

Value:

          (uint64_t)( \
          (((n) & UINT64_C(0x00000000000000FF)) << 56) \
        | (((n) & UINT64_C(0x000000000000FF00)) << 40) \
        | (((n) & UINT64_C(0x0000000000FF0000)) << 24) \
        | (((n) & UINT64_C(0x00000000FF000000)) << 8) \
        | (((n) & UINT64_C(0x000000FF00000000)) >> 8) \
        | (((n) & UINT64_C(0x0000FF0000000000)) >> 24) \
        | (((n) & UINT64_C(0x00FF000000000000)) >> 40) \
        | (((n) & UINT64_C(0xFF00000000000000)) >> 56) \
    )

Definition at line 134 of file tuklib_integer.h.

conv16be

#define conv16be

(

num

)

bswap16(num)

Definition at line 168 of file tuklib_integer.h.

conv16le

#define conv16le

(

num

)

((uint16_t)(num))

Definition at line 177 of file tuklib_integer.h.

conv32be

#define conv32be

(

num

)

bswap32(num)

Definition at line 171 of file tuklib_integer.h.

conv32le

#define conv32le

(

num

)

((uint32_t)(num))

Definition at line 180 of file tuklib_integer.h.

conv64be

#define conv64be

(

num

)

bswap64(num)

Definition at line 174 of file tuklib_integer.h.

conv64le

#define conv64le

(

num

)

((uint64_t)(num))

Definition at line 183 of file tuklib_integer.h.

tuklib_memcpy_aligned

#define tuklib_memcpy_aligned	(		dest,
			src,
			size
	)		memcpy(dest, src, size)

Definition at line 437 of file tuklib_integer.h.

TUKLIB_USE_UNSAFE_ALIGNED_READS

#define TUKLIB_USE_UNSAFE_ALIGNED_READS   1

Definition at line 440 of file tuklib_integer.h.

write16le

#define write16le	(		buf,
			num
	)		write16ne(buf, conv16le(num))

Definition at line 356 of file tuklib_integer.h.

write32le

#define write32le	(		buf,
			num
	)		write32ne(buf, conv32le(num))

Definition at line 357 of file tuklib_integer.h.

Function Documentation

aligned_read16be()

static uint16_t aligned_read16be ( const uint8_t *  buf )

inlinestatic

Definition at line 524 of file tuklib_integer.h.

{
    uint16_t num = aligned_read16ne(buf);
    return conv16be(num);
}

References aligned_read16ne(), conv16be, and num.

aligned_read16le()

static uint16_t aligned_read16le ( const uint8_t *  buf )

inlinestatic

Definition at line 532 of file tuklib_integer.h.

{
    uint16_t num = aligned_read16ne(buf);
    return conv16le(num);
}

References aligned_read16ne(), conv16le, and num.

aligned_read16ne()

static uint16_t aligned_read16ne ( const uint8_t *  buf )

inlinestatic

Definition at line 446 of file tuklib_integer.h.

{
#if defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING) \
        || defined(TUKLIB_USE_UNSAFE_ALIGNED_READS)
    return *(const uint16_t *)buf;
#else
    uint16_t num;
    tuklib_memcpy_aligned(&num, buf, sizeof(num));
    return num;
#endif
}

References num, and tuklib_memcpy_aligned.

Referenced by aligned_read16be(), and aligned_read16le().

aligned_read32be()

static uint32_t aligned_read32be ( const uint8_t *  buf )

inlinestatic

Definition at line 540 of file tuklib_integer.h.

{
    uint32_t num = aligned_read32ne(buf);
    return conv32be(num);
}

References aligned_read32ne(), conv32be, and num.

aligned_read32le()

static uint32_t aligned_read32le ( const uint8_t *  buf )

inlinestatic

Definition at line 548 of file tuklib_integer.h.

{
    uint32_t num = aligned_read32ne(buf);
    return conv32le(num);
}

References aligned_read32ne(), conv32le, and num.

aligned_read32ne()

static uint32_t aligned_read32ne ( const uint8_t *  buf )

inlinestatic

Definition at line 460 of file tuklib_integer.h.

{
#if defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING) \
        || defined(TUKLIB_USE_UNSAFE_ALIGNED_READS)
    return *(const uint32_t *)buf;
#else
    uint32_t num;
    tuklib_memcpy_aligned(&num, buf, sizeof(num));
    return num;
#endif
}

References num, and tuklib_memcpy_aligned.

Referenced by aligned_read32be(), aligned_read32le(), and LZMA_API().

aligned_read64be()

static uint64_t aligned_read64be ( const uint8_t *  buf )

inlinestatic

Definition at line 556 of file tuklib_integer.h.

{
    uint64_t num = aligned_read64ne(buf);
    return conv64be(num);
}

References aligned_read64ne(), conv64be, and num.

aligned_read64le()

static uint64_t aligned_read64le ( const uint8_t *  buf )

inlinestatic

Definition at line 564 of file tuklib_integer.h.

{
    uint64_t num = aligned_read64ne(buf);
    return conv64le(num);
}

References aligned_read64ne(), conv64le, and num.

aligned_read64ne()

static uint64_t aligned_read64ne ( const uint8_t *  buf )

inlinestatic

Definition at line 474 of file tuklib_integer.h.

{
#if defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING) \
        || defined(TUKLIB_USE_UNSAFE_ALIGNED_READS)
    return *(const uint64_t *)buf;
#else
    uint64_t num;
    tuklib_memcpy_aligned(&num, buf, sizeof(num));
    return num;
#endif
}

References num, and tuklib_memcpy_aligned.

Referenced by aligned_read64be(), and aligned_read64le().

aligned_write16ne()

static void aligned_write16ne ( uint8_t *  buf, uint16_t  num  )

inlinestatic

Definition at line 488 of file tuklib_integer.h.

{
#ifdef TUKLIB_USE_UNSAFE_TYPE_PUNNING
    *(uint16_t *)buf = num;
#else
    tuklib_memcpy_aligned(buf, &num, sizeof(num));
#endif
    return;
}

References num, and tuklib_memcpy_aligned.

aligned_write32ne()

static void aligned_write32ne ( uint8_t *  buf, uint32_t  num  )

inlinestatic

Definition at line 500 of file tuklib_integer.h.

{
#ifdef TUKLIB_USE_UNSAFE_TYPE_PUNNING
    *(uint32_t *)buf = num;
#else
    tuklib_memcpy_aligned(buf, &num, sizeof(num));
#endif
    return;
}

References num, and tuklib_memcpy_aligned.

aligned_write64ne()

static void aligned_write64ne ( uint8_t *  buf, uint64_t  num  )

inlinestatic

Definition at line 512 of file tuklib_integer.h.

{
#ifdef TUKLIB_USE_UNSAFE_TYPE_PUNNING
    *(uint64_t *)buf = num;
#else
    tuklib_memcpy_aligned(buf, &num, sizeof(num));
#endif
    return;
}

References num, and tuklib_memcpy_aligned.

bsr32()

static uint32_t bsr32 ( uint32_t  n )

inlinestatic

Definition at line 585 of file tuklib_integer.h.

{
    // Check for ICC first, since it tends to define __GNUC__ too.
#if defined(__INTEL_COMPILER)
    return _bit_scan_reverse(n);
 
#elif TUKLIB_GNUC_REQ(3, 4) && UINT_MAX == UINT32_MAX
    // GCC >= 3.4 has __builtin_clz(), which gives good results on
    // multiple architectures. On x86, __builtin_clz() ^ 31U becomes
    // either plain BSR (so the XOR gets optimized away) or LZCNT and
    // XOR (if -march indicates that SSE4a instructions are supported).
    return (uint32_t)__builtin_clz(n) ^ 31U;
 
#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
    uint32_t i;
    __asm__("bsrl %1, %0" : "=r" (i) : "rm" (n));
    return i;
 
#elif defined(_MSC_VER)
    unsigned long i;
    _BitScanReverse(&i, n);
    return i;
 
#else
    uint32_t i = 31;
 
    if ((n & 0xFFFF0000) == 0) {
        n <<= 16;
        i = 15;
    }
 
    if ((n & 0xFF000000) == 0) {
        n <<= 8;
        i -= 8;
    }
 
    if ((n & 0xF0000000) == 0) {
        n <<= 4;
        i -= 4;
    }
 
    if ((n & 0xC0000000) == 0) {
        n <<= 2;
        i -= 2;
    }
 
    if ((n & 0x80000000) == 0)
        --i;
 
    return i;
#endif
}

References i, and n.

Referenced by index_tree_append().

clz32()

static uint32_t clz32 ( uint32_t  n )

inlinestatic

Definition at line 640 of file tuklib_integer.h.

{
#if defined(__INTEL_COMPILER)
    return _bit_scan_reverse(n) ^ 31U;
 
#elif TUKLIB_GNUC_REQ(3, 4) && UINT_MAX == UINT32_MAX
    return (uint32_t)__builtin_clz(n);
 
#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
    uint32_t i;
    __asm__("bsrl %1, %0\n\t"
        "xorl $31, %0"
        : "=r" (i) : "rm" (n));
    return i;
 
#elif defined(_MSC_VER)
    unsigned long i;
    _BitScanReverse(&i, n);
    return i ^ 31U;
 
#else
    uint32_t i = 0;
 
    if ((n & 0xFFFF0000) == 0) {
        n <<= 16;
        i = 16;
    }
 
    if ((n & 0xFF000000) == 0) {
        n <<= 8;
        i += 8;
    }
 
    if ((n & 0xF0000000) == 0) {
        n <<= 4;
        i += 4;
    }
 
    if ((n & 0xC0000000) == 0) {
        n <<= 2;
        i += 2;
    }
 
    if ((n & 0x80000000) == 0)
        ++i;
 
    return i;
#endif
}

References i, and n.

ctz32()

static uint32_t ctz32 ( uint32_t  n )

inlinestatic

Definition at line 692 of file tuklib_integer.h.

{
#if defined(__INTEL_COMPILER)
    return _bit_scan_forward(n);
 
#elif TUKLIB_GNUC_REQ(3, 4) && UINT_MAX >= UINT32_MAX
    return (uint32_t)__builtin_ctz(n);
 
#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
    uint32_t i;
    __asm__("bsfl %1, %0" : "=r" (i) : "rm" (n));
    return i;
 
#elif defined(_MSC_VER)
    unsigned long i;
    _BitScanForward(&i, n);
    return i;
 
#else
    uint32_t i = 0;
 
    if ((n & 0x0000FFFF) == 0) {
        n >>= 16;
        i = 16;
    }
 
    if ((n & 0x000000FF) == 0) {
        n >>= 8;
        i += 8;
    }
 
    if ((n & 0x0000000F) == 0) {
        n >>= 4;
        i += 4;
    }
 
    if ((n & 0x00000003) == 0) {
        n >>= 2;
        i += 2;
    }
 
    if ((n & 0x00000001) == 0)
        ++i;
 
    return i;
#endif
}

References i, and n.

Referenced by index_tree_append().

read16be()

static uint16_t read16be ( const uint8_t *  buf )

inlinestatic

Definition at line 289 of file tuklib_integer.h.

{
#if defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
    uint16_t num = read16ne(buf);
    return conv16be(num);
#else
    uint16_t num = ((uint16_t)buf[0] << 8) | (uint16_t)buf[1];
    return num;
#endif
}

References conv16be, num, and read16ne().

read16le()

static uint16_t read16le ( const uint8_t *  buf )

inlinestatic

Definition at line 302 of file tuklib_integer.h.

{
#if !defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
    uint16_t num = read16ne(buf);
    return conv16le(num);
#else
    uint16_t num = ((uint16_t)buf[0]) | ((uint16_t)buf[1] << 8);
    return num;
#endif
}

References conv16le, num, and read16ne().

read16ne()

static uint16_t read16ne ( const uint8_t *  buf )

inlinestatic

Definition at line 208 of file tuklib_integer.h.

{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
        && defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
    return *(const uint16_t *)buf;
#else
    uint16_t num;
    memcpy(&num, buf, sizeof(num));
    return num;
#endif
}

References memcpy(), and num.

Referenced by read16be(), and read16le().

read32be()

static uint32_t read32be ( const uint8_t *  buf )

inlinestatic

Definition at line 315 of file tuklib_integer.h.

{
#if defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
    uint32_t num = read32ne(buf);
    return conv32be(num);
#else
    uint32_t num = (uint32_t)buf[0] << 24;
    num |= (uint32_t)buf[1] << 16;
    num |= (uint32_t)buf[2] << 8;
    num |= (uint32_t)buf[3];
    return num;
#endif
}

References conv32be, num, and read32ne().

read32le()

static uint32_t read32le ( const uint8_t *  buf )

inlinestatic

Definition at line 331 of file tuklib_integer.h.

{
#if !defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
    uint32_t num = read32ne(buf);
    return conv32le(num);
#else
    uint32_t num = (uint32_t)buf[0];
    num |= (uint32_t)buf[1] << 8;
    num |= (uint32_t)buf[2] << 16;
    num |= (uint32_t)buf[3] << 24;
    return num;
#endif
}

References conv32le, num, and read32ne().

Referenced by LZMA_API(), lzma_lzma_props_decode(), and lzma_simple_props_decode().

read32ne()

static uint32_t read32ne ( const uint8_t *  buf )

inlinestatic

Definition at line 222 of file tuklib_integer.h.

{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
        && defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
    return *(const uint32_t *)buf;
#else
    uint32_t num;
    memcpy(&num, buf, sizeof(num));
    return num;
#endif
}

References memcpy(), and num.

Referenced by read32be(), and read32le().

read64ne()

static uint64_t read64ne ( const uint8_t *  buf )

inlinestatic

Definition at line 236 of file tuklib_integer.h.

{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
        && defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
    return *(const uint64_t *)buf;
#else
    uint64_t num;
    memcpy(&num, buf, sizeof(num));
    return num;
#endif
}

References memcpy(), and num.

write16be()

static void write16be ( uint8_t *  buf, uint16_t  num  )

inlinestatic

Definition at line 363 of file tuklib_integer.h.

{
    buf[0] = (uint8_t)(num >> 8);
    buf[1] = (uint8_t)num;
    return;
}

References num.

write16ne()

static void write16ne ( uint8_t *  buf, uint16_t  num  )

inlinestatic

Definition at line 250 of file tuklib_integer.h.

{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
        && defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
    *(uint16_t *)buf = num;
#else
    memcpy(buf, &num, sizeof(num));
#endif
    return;
}

References memcpy(), and num.

write32be()

static void write32be ( uint8_t *  buf, uint32_t  num  )

inlinestatic

Definition at line 385 of file tuklib_integer.h.

{
    buf[0] = (uint8_t)(num >> 24);
    buf[1] = (uint8_t)(num >> 16);
    buf[2] = (uint8_t)(num >> 8);
    buf[3] = (uint8_t)num;
    return;
}

References num.

write32ne()

static void write32ne ( uint8_t *  buf, uint32_t  num  )

inlinestatic

Definition at line 263 of file tuklib_integer.h.

{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
        && defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
    *(uint32_t *)buf = num;
#else
    memcpy(buf, &num, sizeof(num));
#endif
    return;
}

References memcpy(), and num.

write64ne()

static void write64ne ( uint8_t *  buf, uint64_t  num  )

inlinestatic

Definition at line 276 of file tuklib_integer.h.

{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
        && defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
    *(uint64_t *)buf = num;
#else
    memcpy(buf, &num, sizeof(num));
#endif
    return;
}

References memcpy(), and num.