Various integer and bit operations. More...

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

Macros
#define	bswap16(n)

#define	bswap32(n)

#define	bswap64(n)

#define	conv16be(num)

#define	conv32be(num)

#define	conv64be(num)

#define	conv16le(num)

#define	conv32le(num)

#define	conv64le(num)

#define	write16le(buf, num)

#define	write32le(buf, num)

#define	write64le(buf, num)

#define	tuklib_memcpy_aligned(dest, src, size)

#define	TUKLIB_USE_UNSAFE_ALIGNED_READS 1

#define	aligned_write16be(buf, num)

#define	aligned_write16le(buf, num)

#define	aligned_write32be(buf, num)

#define	aligned_write32le(buf, num)

#define	aligned_write64be(buf, num)

#define	aligned_write64le(buf, num)

#define	bsf32 ctz32

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: readXXYe(ptr)
Unaligned writes: 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.

Macro Definition Documentation

◆ aligned_write16be

#define aligned_write16be	(		buf,
			num )

Value:

aligned_write16ne((buf), conv16be(num))

buf

char buf[N_BUF]

Definition spewG.c:36

conv16be

#define conv16be(num)

Definition tuklib_integer.h:168

◆ aligned_write16le

#define aligned_write16le	(		buf,
			num )

Value:

aligned_write16ne((buf), conv16le(num))

conv16le

#define conv16le(num)

Definition tuklib_integer.h:177

◆ aligned_write32be

#define aligned_write32be	(		buf,
			num )

Value:

aligned_write32ne((buf), conv32be(num))

conv32be

#define conv32be(num)

Definition tuklib_integer.h:171

◆ aligned_write32le

#define aligned_write32le	(		buf,
			num )

Value:

aligned_write32ne((buf), conv32le(num))

conv32le

#define conv32le(num)

Definition tuklib_integer.h:180

◆ aligned_write64be

#define aligned_write64be	(		buf,
			num )

Value:

aligned_write64ne((buf), conv64be(num))

conv64be

#define conv64be(num)

Definition tuklib_integer.h:174

◆ aligned_write64le

#define aligned_write64le	(		buf,
			num )

Value:

aligned_write64ne((buf), conv64le(num))

conv64le

#define conv64le(num)

Definition tuklib_integer.h:183

◆ bsf32

#define bsf32 ctz32

◆ bswap16

#define bswap16 ( n )

Value:

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

◆ 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) \
    )

◆ 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) \
    )