xwbop.h

浏览该文件的文档.

 
#ifndef __xwos_lib_xwbop_h__
#define __xwos_lib_xwbop_h__
 
#include <xwos/standard.h>
 
#include <xwos/ospl/soc/xwbop.h>
 
/******** ******** macros ******** ********/
#define XWBOP_BIT(n)  ((xwbmp_t)1 << (n))
#define XWBOP_BMP_MASK(n)  ((xwbmp_t)1 << (xwbmp_t)((n) % BITS_PER_XWBMP_T))
#define XWBOP_BMP(n)  ((n) / BITS_PER_XWBMP_T)
#define XWBOP_DIV_ROUND(n, d)  ((n) / (d))
#define XWBOP_DIV_ROUND_UP(n, d)  (((n) + (d) - 1U) / (d))
#define XWBOP_SHIFT_ROUND(n, s)  ((n) >> (s))
#define XWBOP_SHIFT_ROUND_UP(n, s)  (((n) + (1ULL << (s)) - 1ULL) >> (s))
#define BITS_TO_XWU8_T(n)  XWBOP_DIV_ROUND_UP(n, BITS_PER_XWU8_T)
#define BITS_TO_XWBMP_T(n)  XWBOP_DIV_ROUND_UP(n, BITS_PER_XWU8_T * sizeof(xwbmp_t))
#define XWBOP_ROUND(x, n)  ((x) & (~((n) - 1U)))
#define XWBOP_ALIGN(x, n)  (((x) + ((n) - 1U)) & (~((n) - 1U)))
#define XWBOP_TBIT(x, n)  (((x) >> (n)) & 1U)
 
/******** ******** 8-bit 位操作 ******** ********/
#define xwbop_s1m8(a, mask)     *(a) |= (mask)
#define xwbop_c0m8(a, mask)     *(a) &= (~(mask))
#define xwbop_x1m8(a, mask)     *(a) ^= (mask)
 
xwssq_t xwbop_ffs8(xwu8_t x);
xwssq_t xwbop_fls8(xwu8_t x);
xwssq_t xwbop_ffz8(xwu8_t x);
xwssq_t xwbop_flz8(xwu8_t x);
xwu8_t xwbop_rbit8(xwu8_t x);
 
static __xwlib_inline
xwu8_t xwbop_re8(xwu8_t x)
{
        return x;
}
 
xwsz_t xwbop_weight8(xwu8_t x);
 
/******** ******** 16-bit 位操作 ******** ********/
#define xwbop_s1m16(a, mask)    *(a) |= (mask)
#define xwbop_c0m16(a, mask)    *(a) &= (~(mask))
#define xwbop_x1m16(a, mask)    *(a) ^= (mask)
 
xwssq_t xwbop_ffs16(xwu16_t x);
xwssq_t xwbop_fls16(xwu16_t x);
xwssq_t xwbop_ffz16(xwu16_t x);
xwssq_t xwbop_flz16(xwu16_t x);
xwu16_t xwbop_rbit16(xwu16_t x);
xwu16_t xwbop_re16(xwu16_t a);
xwsz_t xwbop_weight16(xwu16_t x);
 
/******** ******** 32-bit 位操作 ******** ********/
#define xwbop_s1m32(a, mask)    *(a) |= (mask)
#define xwbop_c0m32(a, mask)    *(a) &= (~(mask))
#define xwbop_x1m32(a, mask)    *(a) ^= (mask)
 
xwssq_t xwbop_ffs32(xwu32_t x);
xwssq_t xwbop_fls32(xwu32_t x);
xwssq_t xwbop_ffz32(xwu32_t x);
xwssq_t xwbop_flz32(xwu32_t x);
xwu32_t xwbop_rbit32(xwu32_t x);
xwu32_t xwbop_re32(xwu32_t x);
xwsz_t xwbop_weight32(xwu32_t x);
 
/******** ******** 64-bit 位操作 ******** ********/
#define xwbop_s1m64(a64, mask64)        *((xwu64_t *)(a64)) |= (mask64)
#define xwbop_c0m64(a64, mask64)        *((xwu64_t *)(a64)) &= (~(mask64))
#define xwbop_x1m64(a64, mask64)        *((xwu64_t *)(a64)) ^= (mask64)
 
xwssq_t xwbop_ffs64(xwu64_t x);
xwssq_t xwbop_fls64(xwu64_t x);
xwssq_t xwbop_ffz64(xwu64_t x);
xwssq_t xwbop_flz64(xwu64_t x);
xwu64_t xwbop_re64(xwu64_t x);
xwu64_t xwbop_rbit64(xwu64_t x);
xwsz_t xwbop_weight64(xwu64_t x);
 
/******** ******** 位操作 ******** ********/
#define xwbop(type, op, ...)            xwbop_##op##__##type(__VA_ARGS__)
 
#define xwbop_s1m(type, addr, mask)     xwbop(type, s1m, (addr), (mask))
 
#define xwbop_c0m(type, addr, mask)     xwbop(type, c0m, (addr), (mask))
 
#define xwbop_x1m(type, addr, mask)     xwbop(type, x1m, (addr), (mask))
 
#define xwbop_rbit(type, data)          xwbop(type, rbit, (data))
 
#define xwbop_re(type, data)            xwbop(type, re, (data))
 
#define xwbop_ffs(type, data)           xwbop(type, ffs, (data))
 
#define xwbop_fls(type, data)           xwbop(type, fls, (data))
 
#define xwbop_ffz(type, data)           xwbop(type, flz, (data))
 
#define xwbop_flz(type, data)           xwbop(type, flz, (data))
 
#define xwbop_weight(type, data)        xwbop(type, weight, (data))
 
/******** ******** 位操作模板 ******** ********/
#define DEFINE_XWBOP_S1M(type, bw)                                              \
static __xwlib_inline                                                           \
void xwbop_s1m__##type(type * x, type m)                                        \
{                                                                               \
        xwbop_s1m##bw((xwu##bw##_t *)x, (xwu##bw##_t)m);                        \
}
 
#define DEFINE_XWBOP_C0M(type, bw)                                              \
static __xwlib_inline                                                           \
void xwbop_c0m__##type(type * x, type m)                                        \
{                                                                               \
        xwbop_c0m##bw((xwu##bw##_t *)x, (xwu##bw##_t)m);                        \
}
 
#define DEFINE_XWBOP_X1M(type, bw)                                              \
static __xwlib_inline                                                           \
void xwbop_x1m__##type(type * x, type m)                                        \
{                                                                               \
        xwbop_x1m##bw((xwu##bw##_t *)x, (xwu##bw##_t)m);                        \
}
 
#define DEFINE_XWBOP_RBIT(type, bw)                                             \
static __xwlib_inline                                                           \
type xwbop_rbit__##type(type x)                                                 \
{                                                                               \
        return (type)xwbop_rbit##bw((xwu##bw##_t)x);                            \
}
 
#define DEFINE_XWBOP_RE(type, bw)                                               \
static __xwlib_inline                                                           \
type xwbop_re__##type(type x)                                                   \
{                                                                               \
        return (type)xwbop_re##bw((xwu##bw##_t)x);                              \
}
 
#define DEFINE_XWBOP_FFS(type, bw)                                              \
static __xwlib_inline                                                           \
xwssq_t xwbop_ffs__##type(type x)                                               \
{                                                                               \
        return xwbop_ffs##bw((xwu##bw##_t)x);                                   \
}
 
#define DEFINE_XWBOP_FLS(type, bw)                                              \
static __xwlib_inline                                                           \
xwssq_t xwbop_fls__##type(type x)                                               \
{                                                                               \
        return xwbop_fls##bw((xwu##bw##_t)x);                                   \
}
 
#define DEFINE_XWBOP_FLZ(type, bw)                                              \
static __xwlib_inline                                                           \
xwssq_t xwbop_flz__##type(type x)                                               \
{                                                                               \
        return xwbop_flz##bw((xwu##bw##_t)x);                                   \
}
 
#define DEFINE_XWBOP_FFZ(type, bw)                                              \
static __xwlib_inline                                                           \
xwssq_t xwbop_ffz__##type(type x)                                               \
{                                                                               \
        return xwbop_ffz##bw((xwu##bw##_t)x);                                   \
}
 
#define DEFINE_XWBOP_WEIGHT(type, bw)                                           \
static __xwlib_inline                                                           \
xwsq_t xwbop_weight__##type(type x)                                             \
{                                                                               \
        return xwbop_weight##bw((xwu##bw##_t)x);                                \
}
 
#define DEFINE_XWBOP(type, bw)                                                  \
        DEFINE_XWBOP_S1M(type, bw)                                              \
        DEFINE_XWBOP_C0M(type, bw)                                              \
        DEFINE_XWBOP_X1M(type, bw)                                              \
        DEFINE_XWBOP_RBIT(type, bw)                                             \
        DEFINE_XWBOP_RE(type, bw)                                               \
        DEFINE_XWBOP_FFS(type, bw)                                              \
        DEFINE_XWBOP_FLS(type, bw)                                              \
        DEFINE_XWBOP_FLZ(type, bw)                                              \
        DEFINE_XWBOP_FFZ(type, bw)                                              \
        DEFINE_XWBOP_WEIGHT(type, bw)
 
DEFINE_XWBOP(xwu8_t, 8)
DEFINE_XWBOP(xws8_t, 8)
 
DEFINE_XWBOP(xwu16_t, 16)
DEFINE_XWBOP(xws16_t, 16)
 
DEFINE_XWBOP(xwu32_t, 32)
DEFINE_XWBOP(xws32_t, 32)
 
DEFINE_XWBOP(xwu64_t, 64)
DEFINE_XWBOP(xws64_t, 64)
 
#if (16 == BITS_PER_XWSZ_T)
DEFINE_XWBOP(xwsz_t, 16)
#elif (32 == BITS_PER_XWSZ_T)
DEFINE_XWBOP(xwsz_t, 32)
#elif (64 == BITS_PER_XWSZ_T)
DEFINE_XWBOP(xwsz_t, 64)
#endif
 
#if (16 == BITS_PER_XWPTR_T)
DEFINE_XWBOP(xwptr_t, 16)
#elif (32 == BITS_PER_XWPTR_T)
DEFINE_XWBOP(xwptr_t, 32)
#elif (64 == BITS_PER_XWPTR_T)
DEFINE_XWBOP(xwptr_t, 64)
#endif
 
#if (8 == BITS_PER_XWID_T)
DEFINE_XWBOP(xwid_t, 8)
#elif (16 == BITS_PER_XWID_T)
DEFINE_XWBOP(xwid_t, 16)
#elif (32 == BITS_PER_XWID_T)
DEFINE_XWBOP(xwid_t, 32)
#elif (64 == BITS_PER_XWID_T)
DEFINE_XWBOP(xwid_t, 64)
#endif
 
#if (8 == BITS_PER_XWREG_T)
DEFINE_XWBOP(xwreg_t, 8)
#elif (16 == BITS_PER_XWREG_T)
DEFINE_XWBOP(xwreg_t, 16)
#elif (32 == BITS_PER_XWREG_T)
DEFINE_XWBOP(xwreg_t, 32)
#elif (64 == BITS_PER_XWREG_T)
DEFINE_XWBOP(xwreg_t, 64)
#endif
 
#if (16 == BITS_PER_XWSQ_T)
DEFINE_XWBOP(xwsq_t, 16)
#elif (32 == BITS_PER_XWSQ_T)
DEFINE_XWBOP(xwsq_t, 32)
#elif (64 == BITS_PER_XWSQ_T)
DEFINE_XWBOP(xwsq_t, 64)
#endif
 
#if (8 == BITS_PER_XWBMP_T)
DEFINE_XWBOP(xwbmp_t, 8)
#elif (16 == BITS_PER_XWBMP_T)
DEFINE_XWBOP(xwbmp_t, 16)
#elif (32 == BITS_PER_XWBMP_T)
DEFINE_XWBOP(xwbmp_t, 32)
#elif (64 == BITS_PER_XWBMP_T)
DEFINE_XWBOP(xwbmp_t, 64)
#endif
 
DEFINE_XWBOP(xwtk_t, 64)
 
/******** ******** 位图操作 ******** ********/
#define xwbmpop_define(name, bits)  xwbmp_t name[BITS_TO_XWBMP_T(bits)]
 
void xwbmpop_assign(xwbmp_t * bmp, xwbmp_t opd[], xwsz_t num);
 
xwssq_t xwbmpop_cmp(xwbmp_t * bmp, xwbmp_t opd[], xwsz_t num);
 
void xwbmpop_s1all(xwbmp_t * bmp, xwsq_t num);
 
void xwbmpop_c0all(xwbmp_t * bmp, xwsq_t num);
 
void xwbmpop_s1i(xwbmp_t * bmp, xwsq_t n);
 
void xwbmpop_s1m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
void xwbmpop_c0i(xwbmp_t * bmp, xwsq_t n);
 
void xwbmpop_c0m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
void xwbmpop_x1i(xwbmp_t * bmp, xwsq_t n);
 
void xwbmpop_x1m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t1i(xwbmp_t * bmp, xwsq_t n);
 
bool xwbmpop_t1ma(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t1ma_then_c0m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t1mo(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t1mo_then_c0m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t0ma(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t0ma_then_s1m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t0mo(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
bool xwbmpop_t0mo_then_s1m(xwbmp_t * bmp, xwbmp_t msk[], xwsz_t num);
 
void xwbmpop_not(xwbmp_t * bmp, xwsz_t num);
 
void xwbmpop_and(xwbmp_t * bmp, xwbmp_t opd[], xwsz_t num);
 
void xwbmpop_or(xwbmp_t * bmp, xwbmp_t opd[], xwsz_t num);
 
void xwbmpop_xor(xwbmp_t * bmp, xwbmp_t opd[], xwsz_t num);
 
xwssq_t xwbmpop_ffs(xwbmp_t * bmp, xwsz_t num);
 
xwssq_t xwbmpop_ffz(xwbmp_t * bmp, xwsz_t num);
 
xwssq_t xwbmpop_fls(xwbmp_t * bmp, xwsz_t num);
 
xwssq_t xwbmpop_flz(xwbmp_t * bmp, xwsz_t num);
 
xwsz_t xwbmpop_weight(xwbmp_t * bmp, xwsz_t num);
 
#endif /* xwos/lib/xwbop.h */