include/compiler.h

Go to the documentation of this file.

#ifndef COMPILER_H_INCLUDED
#define COMPILER_H_INCLUDED

#include <stdint.h>

/* The "sparse" syntax checker defines __CHECKER__ */
#if defined(__CHECKER__)
# include <compiler/sparse.h>
#elif defined(__GNUC__)
# include <compiler/gcc.h>
#elif defined(__ICCAVR32__) || defined(__ICCAVR__)
# include <compiler/iar.h>
#endif



#ifndef __bitwise
# define __bitwise
#endif

#ifndef __virtual
# define __virtual
#endif

#ifndef __physical
# define __physical
#endif

#ifndef __force
# define __force
#endif




#if !defined(__noreturn) || defined(__DOXYGEN__)
# define __noreturn
#endif

#if !defined(__must_check) || defined(__DOXYGEN__)
# define __must_check
#endif

#if !defined(__used) || defined(__DOXYGEN__)
# define __used
#endif

#ifndef __always_inline
# define __always_inline inline
#endif

#ifndef __nonnull
# define __nonnull(...)
#endif

#ifndef __printf_format
# define __printf_format(fmt_index, first_arg_index)
#endif

#ifndef compiler_align_data
# define compiler_align_data(byte_alignment)
#endif




#ifndef likely
# define likely(exp)    (exp)
#endif

#ifndef unlikely
# define unlikely(exp)  (exp)
#endif

#ifndef barrier
# define barrier()      do { } while (0)
# warning Compiler does not support barrier() -- expect breakage!
#endif

#ifndef is_constant
# define is_constant(exp) (0)
#endif




#define COMPILER_PRAGMA(arg)            _Pragma(#arg)

#ifndef COMPILER_PACK_SET
# define COMPILER_PACK_SET(alignment)   COMPILER_PRAGMA(pack(alignment))
#endif

#ifndef COMPILER_PACK_RESET
# define COMPILER_PACK_RESET()          COMPILER_PRAGMA(pack())
#endif

#ifndef ERROR_FUNC
# define ERROR_FUNC(name, msg)                                  \
        extern int name(void)
#endif


ERROR_FUNC(compiler_priv_bad_size, "Invalid parameter size");

#define compiler_priv_demux_size(size, func, ...)               \
        (((size) == 1) ? func##8(__VA_ARGS__) :                 \
         ((size) == 2) ? func##16(__VA_ARGS__) :                \
         ((size) == 4) ? func##32(__VA_ARGS__) :                \
         compiler_priv_bad_size())


#ifndef compiler_ctz
static inline int_fast8_t compiler_priv_ctz8(uint8_t x)
{
        int_fast8_t bit = 0;

        if (!(x & 0x0f)) {
                bit += 4;
                x >>= 4;
        }
        if (!(x & 0x03)) {
                bit += 2;
                x >>= 2;
        }
        if (!(x & 0x01))
                bit++;

        return bit;
}

static inline int_fast8_t compiler_priv_ctz16(uint16_t x)
{
        int_fast8_t bit = 0;

        if (!(x & 0x00ff)) {
                bit += 8;
                x >>= 8;
        }

        return bit + compiler_priv_ctz8(x);
}

static inline int_fast8_t compiler_priv_ctz32(uint32_t x)
{
        int_fast8_t bit = 0;

        if (!(x & 0x0000ffff)) {
                bit += 16;
                x >>= 16;
        }

        return bit + compiler_priv_ctz16(x);
}

#define compiler_ctz(x) \
        compiler_priv_demux_size(sizeof(x), compiler_priv_ctz, (x))
#endif

#ifndef compiler_clz
static inline int_fast8_t compiler_priv_clz8(uint8_t x)
{
        int_fast8_t bit = 0;

        if (x & 0xf0)
                x >>= 4;
        else
                bit += 4;

        if (x & 0x0c)
                x >>= 2;
        else
                bit += 2;

        if (!(x & 0x02))
                bit++;

        return bit;
}

static inline int_fast8_t compiler_priv_clz16(uint16_t x)
{
        int_fast8_t bit = 0;

        if (x & 0xff00)
                x >>= 8;
        else
                bit += 8;

        return bit + compiler_priv_clz8(x);
}

static inline int_fast8_t compiler_priv_clz32(uint32_t x)
{
        int_fast8_t bit = 0;

        if (x & 0xffff0000)
                x >>= 16;
        else
                bit += 16;

        return bit + compiler_priv_clz16(x);
}

#define compiler_clz(x) \
        compiler_priv_demux_size(sizeof(x), compiler_priv_clz, (x))
#endif

#ifndef compiler_brev
static inline uint8_t compiler_priv_brev8(uint8_t x)
{
        /* swap odd and even bits */
        x = ((x >> 1) & 0x55) | ((x & 0x55) << 1);
        /* swap consecutive pairs */
        x = ((x >> 2) & 0x33) | ((x & 0x33) << 2);
        /* swap nibbles */
        x = ((x >> 4) & 0x0f) | ((x & 0x0f) << 4);

        return x;
}

static inline uint16_t compiler_priv_brev16(uint16_t x)
{
        /* swap odd and even bits */
        x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
        /* swap consecutive pairs */
        x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
        /* swap nibbles */
        x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
        /* swap bytes */
        x = ((x >> 8) & 0x00ff) | ((x & 0x00ff) << 8);

        return x;
}

static inline uint32_t compiler_priv_brev32(uint32_t x)
{
        /* swap odd and even bits */
        x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
        /* swap consecutive pairs */
        x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
        /* swap nibbles */
        x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
        /* swap bytes */
        x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
        /* swap 2-byte pairs */
        x = (x >> 16) | (x << 16);

        return x;
}

#define compiler_brev(x) \
        compiler_priv_demux_size(sizeof(x), compiler_priv_brev, (x))
#endif

static inline int8_t compiler_min_s8(int8_t a, int8_t b)
{
        return (a < b) ? a : b;
}

static inline int16_t compiler_min_s16(int16_t a, int16_t b)
{
        return (a < b) ? a : b;
}

static inline int32_t compiler_min_s32(int32_t a, int32_t b)
{
        return (a < b) ? a : b;
}

static inline int64_t compiler_min_s64(int64_t a, int64_t b)
{
        return (a < b) ? a : b;
}

static inline uint8_t compiler_min_u8(uint8_t a, uint8_t b)
{
        return (a < b) ? a : b;
}

static inline uint16_t compiler_min_u16(uint16_t a, uint16_t b)
{
        return (a < b) ? a : b;
}

static inline uint32_t compiler_min_u32(uint32_t a, uint32_t b)
{
        return (a < b) ? a : b;
}

static inline uint64_t compiler_min_u64(uint64_t a, uint64_t b)
{
        return (a < b) ? a : b;
}

static inline int8_t compiler_max_s8(int8_t a, int8_t b)
{
        return (a > b) ? a : b;
}

static inline int16_t compiler_max_s16(int16_t a, int16_t b)
{
        return (a > b) ? a : b;
}

static inline int32_t compiler_max_s32(int32_t a, int32_t b)
{
        return (a > b) ? a : b;
}

static inline int64_t compiler_max_s64(int64_t a, int64_t b)
{
        return (a > b) ? a : b;
}

static inline uint8_t compiler_max_u8(uint8_t a, uint8_t b)
{
        return (a > b) ? a : b;
}

static inline uint16_t compiler_max_u16(uint16_t a, uint16_t b)
{
        return (a > b) ? a : b;
}

static inline uint32_t compiler_max_u32(uint32_t a, uint32_t b)
{
        return (a > b) ? a : b;
}

static inline uint64_t compiler_max_u64(uint64_t a, uint64_t b)
{
        return (a > b) ? a : b;
}






#endif /* COMPILER_H_INCLUDED */

---