1 /* 2 * Copyright (c) 2016-2023, Arm Limited and Contributors. All rights reserved. 3 * Copyright (c) 2020, NVIDIA Corporation. All rights reserved. 4 * 5 * SPDX-License-Identifier: BSD-3-Clause 6 */ 7 8 #ifndef UTILS_DEF_H 9 #define UTILS_DEF_H 10 11 #include <export/lib/utils_def_exp.h> 12 13 /* Compute the number of elements in the given array */ 14 #define ARRAY_SIZE(a) \ 15 (sizeof(a) / sizeof((a)[0])) 16 17 #define IS_POWER_OF_TWO(x) \ 18 (((x) & ((x) - 1)) == 0) 19 20 #define SIZE_FROM_LOG2_WORDS(n) (U(4) << (n)) 21 22 #define BIT_32(nr) (U(1) << (nr)) 23 #define BIT_64(nr) (ULL(1) << (nr)) 24 25 #ifdef __aarch64__ 26 #define BIT BIT_64 27 #else 28 #define BIT BIT_32 29 #endif 30 31 /* 32 * Create a contiguous bitmask starting at bit position @l and ending at 33 * position @h. For example 34 * GENMASK_64(39, 21) gives us the 64bit vector 0x000000ffffe00000. 35 */ 36 #if defined(__LINKER__) || defined(__ASSEMBLER__) 37 #define GENMASK_32(h, l) \ 38 (((0xFFFFFFFF) << (l)) & (0xFFFFFFFF >> (32 - 1 - (h)))) 39 40 #define GENMASK_64(h, l) \ 41 ((~0 << (l)) & (~0 >> (64 - 1 - (h)))) 42 #else 43 #define GENMASK_32(h, l) \ 44 (((~UINT32_C(0)) << (l)) & (~UINT32_C(0) >> (32 - 1 - (h)))) 45 46 #define GENMASK_64(h, l) \ 47 (((~UINT64_C(0)) << (l)) & (~UINT64_C(0) >> (64 - 1 - (h)))) 48 #endif 49 50 #ifdef __aarch64__ 51 #define GENMASK GENMASK_64 52 #else 53 #define GENMASK GENMASK_32 54 #endif 55 56 /* 57 * This variant of div_round_up can be used in macro definition but should not 58 * be used in C code as the `div` parameter is evaluated twice. 59 */ 60 #define DIV_ROUND_UP_2EVAL(n, d) (((n) + (d) - 1) / (d)) 61 62 #define div_round_up(val, div) __extension__ ({ \ 63 __typeof__(div) _div = (div); \ 64 ((val) + _div - (__typeof__(div)) 1) / _div; \ 65 }) 66 67 #define MIN(x, y) __extension__ ({ \ 68 __typeof__(x) _x = (x); \ 69 __typeof__(y) _y = (y); \ 70 (void)(&_x == &_y); \ 71 (_x < _y) ? _x : _y; \ 72 }) 73 74 #define MAX(x, y) __extension__ ({ \ 75 __typeof__(x) _x = (x); \ 76 __typeof__(y) _y = (y); \ 77 (void)(&_x == &_y); \ 78 (_x > _y) ? _x : _y; \ 79 }) 80 81 #define CLAMP(x, min, max) __extension__ ({ \ 82 __typeof__(x) _x = (x); \ 83 __typeof__(min) _min = (min); \ 84 __typeof__(max) _max = (max); \ 85 (void)(&_x == &_min); \ 86 (void)(&_x == &_max); \ 87 ((_x > _max) ? _max : ((_x < _min) ? _min : _x)); \ 88 }) 89 90 /* 91 * The round_up() macro rounds up a value to the given boundary in a 92 * type-agnostic yet type-safe manner. The boundary must be a power of two. 93 * In other words, it computes the smallest multiple of boundary which is 94 * greater than or equal to value. 95 * 96 * round_down() is similar but rounds the value down instead. 97 */ 98 #define round_boundary(value, boundary) \ 99 ((__typeof__(value))((boundary) - 1)) 100 101 #define round_up(value, boundary) \ 102 ((((value) - 1) | round_boundary(value, boundary)) + 1) 103 104 #define round_down(value, boundary) \ 105 ((value) & ~round_boundary(value, boundary)) 106 107 /* add operation together with checking whether the operation overflowed 108 * The result is '*res', 109 * return 0 on success and 1 on overflow 110 */ 111 #define add_overflow(a, b, res) __builtin_add_overflow((a), (b), (res)) 112 113 /* 114 * Round up a value to align with a given size and 115 * check whether overflow happens. 116 * The rounduped value is '*res', 117 * return 0 on success and 1 on overflow 118 */ 119 #define round_up_overflow(v, size, res) (__extension__({ \ 120 typeof(res) __res = res; \ 121 typeof(*(__res)) __roundup_tmp = 0; \ 122 typeof(v) __roundup_mask = (typeof(v))(size) - 1; \ 123 \ 124 add_overflow((v), __roundup_mask, &__roundup_tmp) ? 1 : \ 125 (void)(*(__res) = __roundup_tmp & ~__roundup_mask), 0; \ 126 })) 127 128 /* 129 * Add a with b, then round up the result to align with a given size and 130 * check whether overflow happens. 131 * The rounduped value is '*res', 132 * return 0 on success and 1 on overflow 133 */ 134 #define add_with_round_up_overflow(a, b, size, res) (__extension__({ \ 135 typeof(a) __a = (a); \ 136 typeof(__a) __add_res = 0; \ 137 \ 138 add_overflow((__a), (b), &__add_res) ? 1 : \ 139 round_up_overflow(__add_res, (size), (res)) ? 1 : 0; \ 140 })) 141 142 /** 143 * Helper macro to ensure a value lies on a given boundary. 144 */ 145 #define is_aligned(value, boundary) \ 146 (round_up((uintptr_t) value, boundary) == \ 147 round_down((uintptr_t) value, boundary)) 148 149 /* 150 * Evaluates to 1 if (ptr + inc) overflows, 0 otherwise. 151 * Both arguments must be unsigned pointer values (i.e. uintptr_t). 152 */ 153 #define check_uptr_overflow(_ptr, _inc) \ 154 ((_ptr) > (UINTPTR_MAX - (_inc))) 155 156 /* 157 * Evaluates to 1 if (u32 + inc) overflows, 0 otherwise. 158 * Both arguments must be 32-bit unsigned integers (i.e. effectively uint32_t). 159 */ 160 #define check_u32_overflow(_u32, _inc) \ 161 ((_u32) > (UINT32_MAX - (_inc))) 162 163 /* Register size of the current architecture. */ 164 #ifdef __aarch64__ 165 #define REGSZ U(8) 166 #else 167 #define REGSZ U(4) 168 #endif 169 170 /* 171 * Test for the current architecture version to be at least the version 172 * expected. 173 */ 174 #define ARM_ARCH_AT_LEAST(_maj, _min) \ 175 ((ARM_ARCH_MAJOR > (_maj)) || \ 176 ((ARM_ARCH_MAJOR == (_maj)) && (ARM_ARCH_MINOR >= (_min)))) 177 178 /* 179 * Import an assembly or linker symbol as a C expression with the specified 180 * type 181 */ 182 #define IMPORT_SYM(type, sym, name) \ 183 extern char sym[];\ 184 static const __attribute__((unused)) type name = (type) sym; 185 186 /* 187 * When the symbol is used to hold a pointer, its alignment can be asserted 188 * with this macro. For example, if there is a linker symbol that is going to 189 * be used as a 64-bit pointer, the value of the linker symbol must also be 190 * aligned to 64 bit. This macro makes sure this is the case. 191 */ 192 #define ASSERT_SYM_PTR_ALIGN(sym) assert(((size_t)(sym) % __alignof__(*(sym))) == 0) 193 194 #define COMPILER_BARRIER() __asm__ volatile ("" ::: "memory") 195 196 /* Compiler builtin of GCC >= 9 and planned in llvm */ 197 #ifdef __HAVE_SPECULATION_SAFE_VALUE 198 # define SPECULATION_SAFE_VALUE(var) __builtin_speculation_safe_value(var) 199 #else 200 # define SPECULATION_SAFE_VALUE(var) var 201 #endif 202 203 /* 204 * Ticks elapsed in one second with a signal of 1 MHz 205 */ 206 #define MHZ_TICKS_PER_SEC U(1000000) 207 208 /* 209 * Ticks elapsed in one second with a signal of 1 KHz 210 */ 211 #define KHZ_TICKS_PER_SEC U(1000) 212 213 #endif /* UTILS_DEF_H */ 214
