util.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2014, Wind River Systems, Inc.
 * Copyright (c) 2023, Intercreate, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <tgmath.h>
 
#include "ic_macros/assert_constant.h"
#include "ic_macros/assert_type.h"
#include "ic_macros/pragma_message.h"
#include "zephyr/build_assert.h"
 
#define _IC_MAKE_SINGLE_EVAL_1(macro, arg1) \
    __builtin_constant_p(arg1) ? macro(arg1) : ({ \
        __auto_type const _##macro##_1_ = (arg1); \
        macro(_##macro##_1_); \
    })
 
#define _IC_MAKE_SINGLE_EVAL_2(macro, arg1, arg2) \
    __builtin_constant_p(arg1) && __builtin_constant_p(arg2) ? macro(arg1, arg2) : ({ \
        __auto_type const _##macro##_1_ = (arg1); \
        __auto_type const _##macro##_2_ = (arg2); \
        macro(_##macro##_1_, _##macro##_2_); \
    })
 
#define _IC_MAKE_SINGLE_EVAL_3(macro, arg1, arg2, arg3) \
    __builtin_constant_p(arg1) && __builtin_constant_p(arg2) && __builtin_constant_p(arg3) \
        ? macro(arg1, arg2, arg3) \
        : ({ \
              __auto_type const _##macro##_1_ = (arg1); \
              __auto_type const _##macro##_2_ = (arg2); \
              __auto_type const _##macro##_3_ = (arg3); \
              macro(_##macro##_1_, _##macro##_2_, _##macro##_3_); \
          })
 
 
#define IC_NUM_BITS(t) (sizeof(t) * 8)
 
#define IC_POINTER_TO_UINT(x) ((uintptr_t) (x))
#define IC_UINT_TO_POINTER(x) ((void *) (uintptr_t) (x))
#define IC_POINTER_TO_INT(x) ((intptr_t) (x))
#define IC_INT_TO_POINTER(x) ((void *) (intptr_t) (x))
 
#define IC_GENMASK32(h, l) (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (32UL - 1 - (h))))
 
#define IC_GENMASK64(h, l) (((~0ULL) - (1ULL << (l)) + 1) & (~0ULL >> (64ULL - 1 - (h))))
 
 
#define IC_G_LSB_GET(value) ((value) & -(value))
 
#define IC_LSB_GET(value) _IC_MAKE_SINGLE_EVAL_1(value)
 
#define IC_G_FIELD_GET(mask, value) (((value) & (mask)) / IC_LSB_GET(mask))
 
#define IC_FIELD_GET(mask, value) _IC_MAKE_SINGLE_EVAL_2(IC_G_FIELD_GET, mask, value)
 
#define IC_G_FIELD_PREP(mask, value) (((value) * IC_LSB_GET(mask)) & (mask))
 
#define IC_FIELD_PREP(mask, value) _IC_MAKE_SINGLE_EVAL_2(IC_G_FIELD_PREP, mask, value)
 
#define IC_ZERO_OR_COMPILE_ERROR(cond) ((int) sizeof(char[1 - 2 * !(cond)]) - 1)
 
#if !defined(__cplusplus)
#    define _IC_IS_ARRAY(array) \
        IC_ZERO_OR_COMPILE_ERROR( \
            !__builtin_types_compatible_p(__typeof__(array), __typeof__(&(array)[0])) \
        )
 
#    define IC_ARRAY_LENGTH(array) \
        (unsigned int) (_IC_IS_ARRAY(array) + (sizeof(array) / sizeof((array)[0])))
 
#    define IC_ARRAY_SIZE(array) (size_t)(_IC_IS_ARRAY(array) + sizeof(array))
 
#endif /* not __cplusplus */
 
#define IC_IS_ARRAY_ELEMENT(array, ptr) \
    ((ptr) && IC_POINTER_TO_UINT(array) <= IC_POINTER_TO_UINT(ptr) \
     && IC_POINTER_TO_UINT(ptr) < IC_POINTER_TO_UINT(&(array)[IC_ARRAY_LENGTH(array)]) \
     && (IC_POINTER_TO_UINT(ptr) - IC_POINTER_TO_UINT(array)) % sizeof((array)[0]) == 0)
 
#define IC_ARRAY_INDEX(array, ptr) \
    IC_IS_ARRAY_ELEMENT(array, ptr) ? (__typeof__((array)[0]) *) (ptr) - (array) : -1
 
#define IC_PART_OF_ARRAY(array, ptr) \
    ((ptr) && IC_POINTER_TO_UINT(array) <= IC_POINTER_TO_UINT(ptr) \
     && IC_POINTER_TO_UINT(ptr) < IC_POINTER_TO_UINT(&(array)[IC_ARRAY_LENGTH(array)]))
 
#define IC_ARRAY_INDEX_FLOOR(array, ptr) \
    IC_PART_OF_ARRAY(array, ptr) \
    ? (IC_POINTER_TO_UINT(ptr) - IC_POINTER_TO_UINT(array)) / sizeof((array)[0]) : -1
 
#define IC_SAME_TYPE(a, b) __builtin_types_compatible_p(__typeof__(a), __typeof__(b))
 
#ifndef __cplusplus
#    define _IC_CONTAINER_OF_VALIDATE(ptr, type, field) \
        IC_BUILD_ASSERT( \
            IC_SAME_TYPE(*(ptr), ((type *) 0)->field) || IC_SAME_TYPE(*(ptr), void), \
            "pointer type mismatch in IC_CONTAINER_OF" \
        );
#else
#    define _IC_CONTAINER_OF_VALIDATE(ptr, type, field)
#endif
 
#define IC_CONTAINER_OF(ptr, type, field) \
    ({ \
        _IC_CONTAINER_OF_VALIDATE(ptr, type, field) \
        ((type *) (((char *) (ptr)) - offsetof(type, field))); \
    })
 
#define IC_G_IROUND_UP(x, align) \
    ((((unsigned long) (x) + ((unsigned long) (align) -1)) / (unsigned long) (align)) \
     * (unsigned long) (align))
 
#define IC_IROUND_UP(x, align) _IC_MAKE_SINGLE_EVAL_2(IC_G_IROUND_UP, x, align)
 
#define IC_G_IROUND_DOWN(x, align) \
    (((unsigned long) (x) / (unsigned long) (align)) * (unsigned long) (align));
 
#define IC_IROUND_DOWN(x, align) _IC_MAKE_SINGLE_EVAL_2(IC_IROUND_DOWN, x, align)
 
#define IC_WB_UP(x) IC_IROUND_UP(x, sizeof(void *))
 
#define IC_WB_DN(x) IC_IROUND_DOWN(x, sizeof(void *))
 
 
#define IC_G_CEIL(x) ceil(x)
 
#define IC_CEIL(x) \
    ({ \
        IC_BUILD_ASSERT( \
            IC_SAME_TYPE(x, float) || IC_SAME_TYPE(x, double) || IC_SAME_TYPE(x, long double), \
            "Argument must be a floating point number!" \
        ); \
        /* use <tgmath.h> */ \
        IC_REQUIRE_CONSTANT(ceil(x)); \
    })
 
#define IC_G_FLOOR(x) floor(x)
 
#define IC_FLOOR(x) \
    ({ \
        IC_BUILD_ASSERT( \
            IC_SAME_TYPE(x, float) || IC_SAME_TYPE(x, double) || IC_SAME_TYPE(x, long double), \
            "Argument must be a floating point number!" \
        ); \
        /* use <tgmath.h> */ \
        IC_REQUIRE_CONSTANT(floor(x)); \
    })
 
#define IC_G_ROUND(x) (__typeof__(x)) (int64_t) ((x) + ((x) >= 0 ? 0.5 : -0.5))
 
#define IC_ROUND(x) \
    ({ \
        IC_BUILD_ASSERT( \
            IC_SAME_TYPE(x, float) || IC_SAME_TYPE(x, double) || IC_SAME_TYPE(x, long double), \
            "Argument must be a floating point number!" \
        ); /* unclear that ARM's <tgmath.h> implements round() */ \
        IC_BUILD_ASSERT((x) >= INT64_MIN || (x) <= INT64_MAX); \
        IC_REQUIRE_CONSTANT(IC_G_ROUND(x)); \
    })
 
#define IC_G_DIV_ROUND_UP(n, d) (((n) + (d) -1) / (d))
 
#define IC_DIV_ROUND_UP(n, d) _IC_MAKE_SINGLE_EVAL_2(IC_G_DIV_ROUND_UP, n, d)
 
#define IC_G_DIV_ROUND_CLOSEST(n, d) \
    ((((n) < 0) ^ ((d) < 0)) ? ((n) - ((d) / 2)) / (d) : ((n) + ((d) / 2)) / (d))
 
#define IC_DIV_ROUND_CLOSEST(n, d) _IC_MAKE_SINGLE_EVAL_2(IC_G_DIV_ROUND_CLOSEST, n, d)
 
#define IC_G_MAX(a, b) (((a) > (b)) ? (a) : (b))
 
#define IC_MAX(a, b) _IC_MAKE_SINGLE_EVAL_2(IC_G_MAX, a, b)
 
 
#define IC_G_MIN(a, b) (((a) < (b)) ? (a) : (b))
 
#define IC_MIN(a, b) _IC_MAKE_SINGLE_EVAL_2(IC_G_MIN, a, b)
 
#define IC_G_CLAMP(val, low, high) (((val) <= (low)) ? (low) : IC_MIN(val, high))
 
#define IC_CLAMP(val, low, high) _IC_MAKE_SINGLE_EVAL_3(IC_G_CLAMP, val, low, high)
 
#define IC_G_IN_RANGE(val, min, max) \
    ((__typeof__(val)) -1) > 0 ? ((val) <= (max)) : ((val) >= (min) && (val) <= (max))
 
#define IC_IN_RANGE(val, min, max) _IC_MAKE_SINGLE_EVAL_3(IC_G_IN_RANGE, val, min, max)
 
#define IC_G_ILOG2(x) \
    (sizeof(__typeof__(x)) > 4 ? (64 - __builtin_clzll(x) - 1) : (32 - __builtin_clz(x) - 1))
 
#define IC_ILOG2(x) \
    __builtin_constant_p(x) ? IC_G_ILOG2(x) : ({ \
        __auto_type const _ic_z_ilog2_x_ = (IC_Z_REQUIRE_UINT(x)); \
        _ic_z_ilog2_x_ < 1 ? -1 : IC_G_ILOG2(_ic_z_ilog2_x_); \
    })
 
#define IC_G_LOG2CEIL(x) (x) < 1 ? 0 : IC_G_ILOG2((x) -1) + 1
 
#define IC_LOG2CEIL(x) _IC_MAKE_SINGLE_EVAL_1(IC_G_LOG2CEIL, x)
 
#define IC_G_NHPOT(x) ((x) < 1 ? 1 : ((x) > (1ULL << 63) ? 0 : 1ULL << IC_G_LOG2CEIL(x)))
 
#define IC_NHPOT(x) _IC_MAKE_SINGLE_EVAL_1(IC_G_NHPOT, x)
 
#define IC_G_POW2_CEIL(x) ((x) <= 2UL ? (x) : (1UL << (8 * sizeof(long) - __builtin_clzl((x) -1))))
 
#define IC_POW2_CEIL(x) _IC_MAKE_SINGLE_EVAL_1(IC_G_POW2_CEIL, x)
 
#define IC_G_IS_POW2(x) (((x) != 0) && (((x) & ((x) -1)) == 0))
 
#define IC_IS_POW2(x) _IC_MAKE_SINGLE_EVAL_1(IC_G_IS_POW2)
 
#define IC_BIT(n) (1UL << (n))
 
#define IC_BIT64(n) (1ULL << (n))
 
#define IC_G_WRITE_BIT(var, bit, set) (set) ? ((var) | IC_BIT(bit)) : ((var) & ~IC_BIT(bit))
 
#define IC_WRITE_BIT(var, bit, set) _IC_MAKE_SINGLE_EVAL_3(IC_G_WRITE_BIT, var, bit, set)
 
#define IC_BIT_MASK(n) (IC_BIT(n) - 1UL)
 
#define IC_BIT64_MASK(n) (IC_BIT64(n) - 1ULL)
 
#define IC_G_IS_SHIFTED_BIT_MASK(m, s) (!(((m) >> (s)) & (((m) >> (s)) + 1U)))
 
#define IC_IS_SHIFTED_BIT_MASK(m, s) _IC_MAKE_SINGLE_EVAL_2(IC_G_IS_SHIFTED_BIT_MASK, m, s)
 
#define IC_G_IS_BIT_MASK(m) IC_G_IS_SHIFTED_BIT_MASK(m, 0)
 
#define IC_IS_BIT_MASK(m) IC_IS_SHIFTED_BIT_MASK(m, 0)
 
#define IC_G_BSWAP24(x) \
    (((x) >> 16) & 0x0000FF) | (((x) >> 00) & 0x00FF00) | ((((x) & 0x0000FF) << 16))
 
#define IC_BSWAP24(x) _IC_MAKE_SINGLE_EVAL_1(IC_G_BSWAP24, x)
 
#ifdef __cplusplus
}
#endif