include/util.h

Go to the documentation of this file.

#ifndef UTIL_H_INCLUDED
#define UTIL_H_INCLUDED

#include <compiler.h>
#include <stdint.h>
#include <types.h>

#define xstr(s)         str(s)

#define str(s)          #s

#define ARRAY_LEN(a)    (sizeof(a) / sizeof((a)[0]))

static inline int isdigit(int c)
{
        return (c >= '0') && (c <= '9');
}

static inline int iscntrl(int c)
{
        return (c < 32) || (c >= 127);
}

static inline int isspace(int c)
{
        return c == ' ';
}

#define container_of(ptr, type, member)                                 \
        ((type *)((uintptr_t)(ptr) - offsetof(type, member)))



#define min_s(a, b)                                                     \
        ((sizeof(a) == 1) && (sizeof(b) == 1) ? compiler_min_s8(a, b)   \
        : (sizeof(a) <= 2) && (sizeof(b) <= 2) ? compiler_min_s16(a, b) \
        : (sizeof(a) <= 4) && (sizeof(b) <= 4) ? compiler_min_s32(a, b) \
        : compiler_min_s64(a, b))

#define min_u(a, b)                                                     \
        ((sizeof(a) == 1) && (sizeof(b) == 1) ? compiler_min_u8(a, b)   \
        : (sizeof(a) <= 2) && (sizeof(b) <= 2) ? compiler_min_u16(a, b) \
        : (sizeof(a) <= 4) && (sizeof(b) <= 4) ? compiler_min_u32(a, b) \
        : compiler_min_u64(a, b))

#define max_s(a, b)                                                     \
        ((sizeof(a) == 1) && (sizeof(b) == 1) ? compiler_max_s8(a, b)   \
        : (sizeof(a) <= 2) && (sizeof(b) <= 2) ? compiler_max_s16(a, b) \
        : (sizeof(a) <= 4) && (sizeof(b) <= 4) ? compiler_max_s32(a, b) \
        : compiler_max_s64(a, b))

#define max_u(a, b)                                                     \
        ((sizeof(a) == 1) && (sizeof(b) == 1) ? compiler_max_u8(a, b)   \
        : (sizeof(a) <= 2) && (sizeof(b) <= 2) ? compiler_max_u16(a, b) \
        : (sizeof(a) <= 4) && (sizeof(b) <= 4) ? compiler_max_u32(a, b) \
        : compiler_max_u64(a, b))


int_fast8_t ilog2_undefined(void);

__always_inline static int_fast8_t ilog2(uint32_t x)
{
        if (is_constant(x))
                return ((x) & (1ULL << 31) ? 31 :
                        (x) & (1ULL << 30) ? 30 :
                        (x) & (1ULL << 29) ? 29 :
                        (x) & (1ULL << 28) ? 28 :
                        (x) & (1ULL << 27) ? 27 :
                        (x) & (1ULL << 26) ? 26 :
                        (x) & (1ULL << 25) ? 25 :
                        (x) & (1ULL << 24) ? 24 :
                        (x) & (1ULL << 23) ? 23 :
                        (x) & (1ULL << 22) ? 22 :
                        (x) & (1ULL << 21) ? 21 :
                        (x) & (1ULL << 20) ? 20 :
                        (x) & (1ULL << 19) ? 19 :
                        (x) & (1ULL << 18) ? 18 :
                        (x) & (1ULL << 17) ? 17 :
                        (x) & (1ULL << 16) ? 16 :
                        (x) & (1ULL << 15) ? 15 :
                        (x) & (1ULL << 14) ? 14 :
                        (x) & (1ULL << 13) ? 13 :
                        (x) & (1ULL << 12) ? 12 :
                        (x) & (1ULL << 11) ? 11 :
                        (x) & (1ULL << 10) ? 10 :
                        (x) & (1ULL <<  9) ?  9 :
                        (x) & (1ULL <<  8) ?  8 :
                        (x) & (1ULL <<  7) ?  7 :
                        (x) & (1ULL <<  6) ?  6 :
                        (x) & (1ULL <<  5) ?  5 :
                        (x) & (1ULL <<  4) ?  4 :
                        (x) & (1ULL <<  3) ?  3 :
                        (x) & (1ULL <<  2) ?  2 :
                        (x) & (1ULL <<  1) ?  1 :
                        (x) & (1ULL <<  0) ?  0 :
                        ilog2_undefined());

        return 31 - compiler_clz(x);
}

__always_inline static bool is_power_of_two(unsigned long x)
{
        return x && !(x & (x - 1));
}

ERROR_FUNC(priv_round_down_bad_type, "Invalid type passed to round_down");

#define round_down(x, order)                                                    \
                (sizeof(x) == 4 ? round_down32((uint32_t)(x), (order)) :        \
                 sizeof(x) == 2 ? round_down16((uint16_t)(x), (order)) :        \
                 sizeof(x) == 1 ? round_down8 (( uint8_t)(x), (order)) :        \
                (priv_round_down_bad_type(),1))

static inline uint8_t round_down8(uint8_t x, unsigned int order)
{
        return (x & ~((1U << order) - 1));
}

static inline uint16_t round_down16(uint16_t x, unsigned int order)
{
        return (x & ~((1U << order) - 1));
}

static inline uint32_t round_down32(uint32_t x, unsigned int order)
{
        return (x & ~((1UL << order) - 1));
}

ERROR_FUNC(priv_round_up_bad_type, "Invalid type passed to round_up");

#define round_up(x, order)                                              \
                (sizeof(x) == 4 ? round_up32((uint32_t)(x), (order)) :  \
                 sizeof(x) == 2 ? round_up16((uint16_t)(x), (order)) :  \
                 sizeof(x) == 1 ? round_up8 (( uint8_t)(x), (order)) :  \
                (priv_round_up_bad_type(),1))

static inline uint8_t round_up8(uint8_t x, unsigned int order)
{
        return round_down8(x + (1U << order) - 1, order);
}

static inline uint16_t round_up16(uint16_t x, unsigned int order)
{
        return round_down16(x + (1U << order) - 1, order);
}

static inline uint32_t round_up32(uint32_t x, unsigned int order)
{
        return round_down32(x + (1UL << order) - 1, order);
}

static inline unsigned long word_align(unsigned long x)
{
        return round_up(x, 2);
}

#ifdef CONFIG_PAGE_SIZE

static inline unsigned long page_align(unsigned long x)
{
        return (x + CONFIG_PAGE_SIZE - 1) & ~(CONFIG_PAGE_SIZE - 1);
}
#endif

#define div_ceil(a, b)  (((a) + (b) - 1) / (b))


#endif /* UTIL_H_INCLUDED */

---